{"text": "\n*This notebook contains course material from [CBE40455](https://jckantor.github.io/CBE40455) by\nJeffrey Kantor (jeff at nd.edu); the content is available [on Github](https://github.com/jckantor/CBE40455.git).\nThe text is released under the [CC-BY-NC-ND-4.0 license](https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode),\nand code is released under the [MIT license](https://opensource.org/licenses/MIT).*\n\n\n< [Risk and Diversification](http://nbviewer.jupyter.org/github/jckantor/CBE40455/blob/master/notebooks/07.00-Risk-and-Diversification.ipynb) | [Contents](toc.ipynb) | [Geometric Brownian Motion](http://nbviewer.jupyter.org/github/jckantor/CBE40455/blob/master/notebooks/07.02-Geometric-Brownian-Motion.ipynb) >
\n\n\n\n\n\n\n\n interactive(children=(IntSlider(value=1, continuous_update=False, description='N', layout=Layout(height='20px'…\n\n\n# Complejidad y Sobreajuste\n\nEn el ejemplo anterior vimos que se puede obtener modelos más flexibles si aumentamos el grado del polinomio \n\n> Aumentar la cantidad de parámetros (grados de libertad) hace al modelo más flexible y más complejo\n\nSi la flexibilidad es excesiva aproximamos los datos con cero error\n\nEsto no es bueno ya que estamos aprendiendo \"de memoria\" los datos y ajustandonos al ruido\n\n> Sobreajuste: Aprender perfectamente los datos usados para entrenar\n\nEl modelo sobreajustado predice muy mal los datos \"que no ha visto\"\n\n> El sobreajuste es inversamente proporcional a la capacidad de generalización\n\nPor esta razón usamos conjuntos de validación\n\n\n\nFigura: https://www.d2l.ai/chapter_multilayer-perceptrons/underfit-overfit.html\n\n# Representatividad y Validación\n\nEl primer paso para entrenar nuestro modelo es obtener datos (duh)\n\nEs crítico que los datos que utilizemos **representen** adecuadamente el problema que queremos resolver\n\nSea un espacio de datos (circulo negro) y muestras (puntos azules), ¿que puede decir de los siguientes casos?\n\n\n```python\nfrom matplotlib.patches import Circle\nfig, ax = plt.subplots(1, 2, figsize=(7, 3))\nnp.random.seed(19)\nfor ax_ in ax:\n ax_.axis('off') \n ax_.set_xlim([-3, 3])\n ax_.set_ylim([-3, 3])\nr = 2.5*np.random.rand(100); t = np.random.rand(100);\nax[0].scatter(r*np.cos(2.0*np.pi*t), r*np.sin(2.0*np.pi*t))\np = Circle((0, 0), 3, fill=False, ec='k')\nax[0].add_artist(p)\nr = 2.5*np.random.rand(100); t = np.random.rand(100);\nax[1].scatter(r*np.cos(t), r*np.sin(t))\np = Circle((0, 0), 3, fill=False, ec='k')\nax[1].add_artist(p); \n```\n\n\n \n\n\n\n\n\n\nSiempre que podamos controlar el proceso de muestreo debemos poner atención a evitar **sesgos**\n\nAsumiendo que nuestro dataset es representativo el siguiente paso es **entrenar**\n\nPara combatir el sobreajuste podemos usar **estrategias de validación**\n\nConsisten en separar el conjunto en dos o más subconjuntos\n- Holdout: Entrenamiento/Validación/Prueba\n- K-fold cross-validation y Leave one-out (N-fold) cross-validation\n- Versiones estratificadas/balanceadas de las anteriores\n\nPara que nuestro conjuntos de entrenamiento y validación sigan siendo representativos del total los **seleccionamos aleatoriamente**\n\nMedimos $L(\\theta)$ en entrenamiento y validación\n\n> Optimizamos nuestro modelo minimizando el error de entrenamiento\n\n> Seleccionamos los parámetros e hiper-parámetros que dan mínimo error de validación\n\n> Comparamos distintas familias de modelos con el error de prueba\n\nEn el ejemplo anterior:\n\n\n```python\nfig, ax = plt.subplots(figsize=(6, 4), tight_layout=True)\nN_values = np.arange(1, 11)\nmse = np.zeros(shape=(len(N_values), 2))\nfor i, N in enumerate(N_values):\n Phi = poly_basis(x, N)\n theta_hat = np.linalg.lstsq(Phi[train_idx, :], Y[train_idx], rcond=None)[0]\n mse[i, 0] = np.mean(np.power(Y[train_idx] - np.dot(Phi[train_idx, :], theta_hat), 2))\n mse[i, 1] = np.mean(np.power(Y[valid_idx] - np.dot(Phi[valid_idx, :], theta_hat), 2))\nax.plot(N_values, mse[:, 0], label='Entrenamiento')\nax.plot(N_values, mse[:, 1], label='Validación')\nidx_best = np.argmin(mse[:, 1])\nax.scatter(N_values[idx_best], mse[idx_best, 1], c='k', s=100)\nplt.legend()\nax.set_ylim([1e-4, 1e+4])\nax.set_yscale('log')\nax.set_xlabel('Grado del polinomio')\nax.set_ylabel('Loss');\n```\n\n\n \n\n\n\n\n\n\nEn resumen\n\n- Bajo error de entrenamiento y de validación: **Ideal**\n\n- Bajo error de entrenamiento y alto error de validación: **Modelo sobreajustado**\n\n- Alto error de entrenamiento y de validación: Considera otro modelo y/o revisa tu código\n\n\n## Neurona artificial o regresor logístico\n\nModelo para aprender una mapeo entre una o más variables continuas (atributos) hacia una variable binaria (objetivo)\n\n$$\ny_i \\leftarrow f_\\theta(\\vec x_i) = \\mathcal{S} \\left(\\theta_0 + \\sum_{j=1}^M \\theta_j x_{ij}\\right) \n$$\n\ndonde $\\mathcal{S}(z) = \\frac{1}{1+\\exp(-z)} \\in [0, 1]$ se conoce como función logística o sigmoide\n\n> Modelo de clasificación binaria (dos clases)\n\nPodemos interpretar la salida del clasificador como una probabilidad\n\n\n\n\n```python\n\n```\n\n\n```python\ndata = np.concatenate((np.random.randn(50, 2), 1.5 + np.random.randn(50, 2)), axis=0)\nlabel = np.array([0]*50 + [1]*50)\nfig, ax = plt.subplots(1, figsize=(9, 4))\nfrom matplotlib import cm\n#fig.colorbar(cm.ScalarMappable(cmap=plt.cm.RdBu_r), ax=ax)\nx_min, x_max = data[:, 0].min() - 0.5, data[:, 0].max() + 0.5\ny_min, y_max = data[:, 1].min() - 0.5, data[:, 1].max() + 0.5\nxx, yy = np.meshgrid(np.arange(x_min, x_max, 0.05), np.arange(y_min, y_max, 0.05))\n\ndef sigmoid(X, w, b):\n Z = np.dot(X, w) + b\n return 1./(1 + np.exp(-Z))\n\ndef update_plot(w1, w2, b): \n ax.cla()\n ax.scatter(data[:50, 0], data[:50, 1], c='k', s=20)\n ax.scatter(data[50:, 0], data[50:, 1], c='k', s=20, marker='x')\n ax.contourf(xx, yy, sigmoid(np.c_[xx.ravel(), yy.ravel()], np.array([w1, w2]), b).reshape(xx.shape), \n cmap=plt.cm.RdBu_r, alpha=0.75)\n\n\nwidgets.interact(update_plot, \n w1=FloatSlider_nice(min=-10, max=10),\n w2=FloatSlider_nice(min=-10, max=10),\n b=FloatSlider_nice(min=-10, max=10));\n```\n\n\n \n\n\n\n\n\n\n\n interactive(children=(FloatSlider(value=0.0, continuous_update=False, description='w1', layout=Layout(height='…\n\n\n¿Qué función de costo es apropiada en este caso?\n\nTipicamente se usa la **Entropía Cruzada Binaria**\n\n$$\nL(\\theta) = \\sum_{i=1}^N -y_i \\log( f_\\theta(\\vec x_i) ) - (1-y_i) \\log(1 - f_\\theta(\\vec x_i))\n$$\n\n¿Por qué?\n\nCalculemos su gradiente \n$$\n\\begin{align}\n\\frac{d}{d \\theta_j} L(\\theta) &= \\sum_{i=1}^N \\left(-\\frac{y_i}{f_\\theta(\\vec x_i)} + \\frac{1-y_i}{1 - f_\\theta(\\vec x_i)}\\right) \\frac{f_\\theta(\\vec x_i)}{d\\theta_j} \\nonumber \\\\\n&= (y_i - f_\\theta(\\vec x_i)) x_{ij}\n\\end{align}\n$$\n\nPor la no linealidad $f_\\theta(\\vec x_i)$ ya no podemos despejar analiticamente $\\theta$ \n\n> Podemos usar métodos de optimización iterativos\n\n## Optimización: Método de Newton\n\nSea el valor actual del vector de parámetros $\\theta_t$\n\nQueremos encontrar el mejor \"próximo valor\" según nuestra función objetivo\n$$\n\\theta_{t+1} = \\theta_t + \\Delta \\theta\n$$\nConsideremos la aproximación de Taylor de segundo orden de $f$\n$$\nf(\\theta_{t} + \\Delta \\theta) \\approx f(\\theta_t) + \\nabla f (\\theta_t) \\Delta \\theta + \\frac{1}{2} \\Delta \\theta^T H_f (\\theta_t) \\Delta \\theta \n$$\nDerivando en función de $\\Delta \\theta$ e igualando a cero tenemos\n$$\n\\begin{align}\n\\nabla f (\\theta_t) + H_f (\\theta_t) \\Delta \\theta &= 0 \\nonumber \\\\\n\\Delta \\theta &= - [H_f (\\theta_t)]^{-1}\\nabla f (\\theta_t) \\nonumber \\\\\n\\theta_{t+1} &= \\theta_{t} - [H_f (\\theta_t)]^{-1}\\nabla f (\\theta_t) \\nonumber \\\\\n\\end{align}\n$$\n\n- Se obtiene una regla iterativa en función del **Gradiente** y del **Hessiano**\n- La solución depende de $\\theta_0$\n- \"Asumimos\" que la aproximación de segundo orden es \"buena\"\n- Si nuestro modelo tiene $N$ parámetros el Hessiano es de $N\\times N$, ¿Qué pasa si $N$ es grande?\n\n## Optimización: Gradiente descendente\n\nSi el Hessiano es prohibitivo podemos usar una aproximación de primer orden\n\nEl método más clásico es el **gradiente descendente**\n$$\n\\theta_{t+1} = \\theta_{t} - \\eta \\nabla f (\\theta_t)\n$$\n\ndonde hemos reemplazado el Hessiano por una constante $\\eta$ llamado \"paso\" o \"tasa de aprendizaje\"\n\n- ¿Cómo cambia la optimización con distintos $\\eta$?\n- ¿Qué ocurre cuando la superficie de error tiene mínimos locales?\n\n\n```python\nplt.close('all'); fig, ax = plt.subplots(2, figsize=(7, 4), tight_layout=True, sharex=True)\nx = np.linspace(-4, 6, num=100)\nf = lambda theta : 5+ (theta-1.)**2 #+ 10*np.sin(theta)\ndf = lambda theta : 2*(theta -1.) #+ 10*np.cos(theta)\ndf2 = lambda theta : 2 #- 10*np.cos(theta)\n\nt = 10*np.random.rand(10) - 4.\nax[0].plot(x, f(x))\nsc = ax[0].scatter(t, f(t), s=100)\n\nax[1].set_xlabel(r'$\\theta$')\nax[0].set_ylabel(r'$f(\\theta)$')\nax[1].plot(x, -df(x))\nax[1].set_ylabel(r'$-\\nabla f(\\theta)$')\neta = 0.01\n\ndef update(n):\n t = sc.get_offsets()[:, 0]\n t -= eta*df(t)\n #t -= df(t)/(df2(t)+10)\n sc.set_offsets(np.c_[t, f(t)])\n \nanim = animation.FuncAnimation(fig, update, frames=100, interval=200, repeat=False, blit=True)\n```\n\n\n \n\n\n\n\n\n\n# Neurona artificial en [PyTorch](https://pytorch.org/)\n\n\n```python\nimport torch\nfrom torch.utils.data import DataLoader, TensorDataset, Subset \n\ntorch_set = TensorDataset(torch.from_numpy(data.astype('float32')), \n torch.from_numpy(label.astype('float32')))\n\nimport sklearn.model_selection\ntrain_idx, test_idx = next(sklearn.model_selection.ShuffleSplit(train_size=0.6).split(data, label))\ntorch_train_loader = DataLoader(Subset(torch_set, train_idx), shuffle=True, batch_size=16)\ntorch_valid_loader = DataLoader(Subset(torch_set, test_idx), shuffle=False, batch_size=256)\n```\n\n /home/hackerter/.local/lib/python3.6/site-packages/sklearn/model_selection/_split.py:1788: FutureWarning: From version 0.21, test_size will always complement train_size unless both are specified.\n FutureWarning)\n\n\n\n```python\nclass Neurona(torch.nn.Module):\n\n def __init__(self): \n \n super(Neurona, self).__init__()\n \n self.fc = torch.nn.Linear(in_features=2, out_features=1, bias=True)\n self.activation = torch.nn.Sigmoid()\n \n def forward(self, x):\n return self.activation(self.fc(x))\n```\n\n\n```python\nfig, ax = plt.subplots(1, 2, figsize=(8, 3.5), tight_layout=True)\n\nnet = Neurona()\nn_epochs = 1000\noptimizer = torch.optim.SGD(net.parameters(), lr=1e-2)\ncriterion = torch.nn.BCELoss(reduction='sum') \nrunning_loss = np.zeros(shape=(n_epochs, 2))\n\ndef train_one_epoch(net):\n train_loss, valid_loss = 0.0, 0.0\n for sample_data, sample_label in torch_train_loader:\n output = net(sample_data)\n optimizer.zero_grad() \n loss = criterion(output, sample_label) \n train_loss += loss.item()\n loss.backward()\n optimizer.step()\n for sample_data, sample_label in torch_valid_loader:\n output = net(sample_data)\n loss = criterion(output, sample_label) \n valid_loss += loss.item()\n return train_loss/torch_train_loader.dataset.__len__(), valid_loss/torch_valid_loader.dataset.__len__()\n \ndef update_plot(k):\n global net, running_loss\n [ax_.cla() for ax_ in ax]\n running_loss[k, 0], running_loss[k, 1] = train_one_epoch(net)\n Z = net.forward(torch.from_numpy(np.c_[xx.ravel(), yy.ravel()].astype('float32')))\n Z = Z.detach().numpy().reshape(xx.shape)\n ax[0].contourf(xx, yy, Z, cmap=plt.cm.RdBu_r, alpha=1., vmin=0, vmax=1)\n for i, (marker, name) in enumerate(zip(['o', 'x'], ['Train', 'Test'])):\n ax[0].scatter(data[label==i, 0], data[label==i, 1], color='k', s=10, marker=marker, alpha=0.5)\n ax[1].plot(np.arange(0, k+1, step=1), running_loss[:k+1, i], '-', label=name+\" cost\")\n plt.legend(); ax[1].grid()\n\n#update_plot(0)\nanim = animation.FuncAnimation(fig, update_plot, frames=n_epochs, \n interval=10, repeat=False, blit=False)\n```\n\n\n \n\n\n\n\n\n\n# Métricas: Evaluando un clasificador binario\n\nLa salida de este clasificador es un valor en el rango $[0, 1]$\n\nPara tomar un decisión binaria se debe seleccionar un umbral $\\mathcal{T}$ tal que\n\n$$\nd_i = \n\\begin{cases} \n0, & \\text{si } f_\\theta(\\vec x_i) < \\mathcal{T} \\\\ \n1, & \\text{si } f_\\theta(\\vec x_i) \\geq \\mathcal{T}\n\\end{cases}\n$$\n\nUna vez seleccionado el umbral se puede contar la cantidad de \n- **True positives** (TP): Era clase (1) y lo clasifico como (1)\n- **True negative** (TN): Era clase (0) y lo clasifico como (0)\n- **False positives** (FP): Era clase (0) y lo clasifico como (1): Error tipo I\n- **False negative** (FN): Era clase (1) y lo clasifico como (0): Error tipo II\n\nA partir de estas métricas se construye la **tabla de confusión** del clasificador\n\n|Clasificado como/En realidad era|Positivo|Negativo|\n|---|---|---|\n|Positivo:|TP | FP |\n|Negativo:| FN | TN |\n\nEn base a estas métricas se construyen otras \n$$\n\\text{Recall} = \\frac{TP}{TP + FN}\n$$\ntambién conocida como la **Tasa de verdaderos positivos** (TPR) o sensitividad\n\n> TPR: La proporción de positivos correctamente clasificados respecto al total de positivos\n\n$$\n\\text{FPR} = \\frac{FP}{TN + FP} = 1 - \\frac{TN}{TN + FP}\n$$\n\nla **tasa de falsos positivos** (FPR) también representada como \"1 - especificidad\"\n\n\n> FPR: La proporción de negativos incorrectamente clasificados respecto al total de negativos\n\n$$\n\\text{Precision} = \\frac{TP}{TP + FP}\n$$\n\ntambién conocido como pureza\n\n> Precision: La proporción de positivos correctamente clasificados respecto a todos los ejemplos clasificados como positivo\n\n$$\n\\text{Accuracy} = \\frac{TP+TN}{TP + FP + FN+ TN}\n$$\n\n> Accuracy: La proporción de ejemplos correctamente clasificados\n\n$$\n\\text{f1-score} = \\frac{2*\\text{Recall}*\\text{Precision}}{\\text{Recall} + \\text{Precision}}\n$$\n\n> f1-score: Media armónica entre Recall y Precision asumiendo igual ponderación\n\nSi las clases son desbalanceadas entonces f1-score es más aconsejable que accuracy\n\n\n```python\nnet = Neurona()\nprobability = net(torch_set.tensors[0]).detach().numpy()\nimport sklearn.metrics\n\nprint(\"Matriz de confusión:\")\nprint(sklearn.metrics.confusion_matrix(y_true=torch_set.tensors[1].numpy().astype(int), \n y_pred=probability[:, 0] > 0.5))\n\nprint(sklearn.metrics.classification_report(y_true=torch_set.tensors[1].numpy().astype(int), \n y_pred=probability[:, 0] > 0.5))\n```\n\n Matriz de confusión:\n [[40 10]\n [ 9 41]]\n precision recall f1-score support\n \n 0 0.82 0.80 0.81 50\n 1 0.80 0.82 0.81 50\n \n micro avg 0.81 0.81 0.81 100\n macro avg 0.81 0.81 0.81 100\n weighted avg 0.81 0.81 0.81 100\n \n\n\nNotar que a distintos umbrales $\\mathcal{T}$ se obtienen distintas tablas de confusión\n\nSe midemos estas métricas usando distintos umbrales podemos construir una curva de desempeño\n\nTipicamente se usan\n- Curva ROC: TPR vs FPR\n- Curva Precision vs Recall\n\n\n```python\nfpr, tpr, th = sklearn.metrics.roc_curve(y_true=torch_set.tensors[1].numpy().astype(int), \n y_score=probability[:, 0])\n\nfig, ax = plt.subplots(figsize=(7, 4))\nax.plot(fpr, tpr);\nax.set_xlabel('Tasa de Falsos positivos')\nax.set_ylabel('Tasa de Verdaderos Positivos (Recall)')\nax.set_title('AUC: %f' %sklearn.metrics.auc(fpr, tpr))\n```\n\n\n \n\n\n\n\n\n\n\n\n\n Text(0.5, 1.0, 'AUC: 0.866000')\n\n\n\n\n```python\nprec, rec, th = sklearn.metrics.precision_recall_curve(y_true=torch_set.tensors[1].numpy().astype(int), \n probas_pred=probability[:, 0])\n\nfig, ax = plt.subplots(figsize=(7, 4))\nax.plot(rec, prec, '-');\nax.set_xlabel('Recall')\nax.set_ylabel('Precision')\n```\n\n\n \n\n\n\n\n\n\n\n\n\n Text(0, 0.5, 'Precision')\n\n\n\n# Ojo con:\n\n\n#### La distribución de los datos donde se aplicará el clasificador es distinta a la que usaste para entrenar/validar\n\nActualiza tus conjuntos de datos para que sean representativos!\n\n#### Usa los subconjuntos adecuadamente\n\nAjusta los parámetros con el set de validación\n\nCompara distintas familias de modelos con el set de prueba\n\n\n#### La métrica que usas no es la adecuada para el problema\n\nSi el problema tiene clases desbalanceadas el *accuracy* puede ser muy alto, contrasta usando métricas sencibles al desbalance (e.g. *f1-score*)\n\n#### Mi modelo se sobreajusta de inmediato\n\nPrueba disminuyendo la complejidad/arquitectura del modelo o añadiendo **regularización**\n\nEsto también puede ser señal de que necesitas más ejemplos para entrenar\n\nSe pueden usar **Técnicas de aumentación** de datos\n\n#### Mi modelo no está aprendiendo\n\nSi estas seguro que no hay bugs prueba aumentando la complejidad del modelo\n\n#### Estudia los errores de tu modelo para mejorarlo\n\nAnaliza los datos mal clasificados y busca patrones\n\nRevisa que las etiquetas estén correctas\n\nRevisa que los atributos estén adecuadamente calculados\n\nPropon nuevos atributos que ayuden a clasificador los ejemplos difíciles\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "8b79462057a0638b7c66775ab4ae11c5c166f64c", "size": 701882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "unidad1/1_fundamentos.ipynb", "max_stars_repo_name": "hackerter/INFO267", "max_stars_repo_head_hexsha": "0382701d4be05fe3533707ebf114214c90e4b3c1", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "unidad1/1_fundamentos.ipynb", "max_issues_repo_name": "hackerter/INFO267", "max_issues_repo_head_hexsha": "0382701d4be05fe3533707ebf114214c90e4b3c1", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "unidad1/1_fundamentos.ipynb", "max_forks_repo_name": "hackerter/INFO267", "max_forks_repo_head_hexsha": "0382701d4be05fe3533707ebf114214c90e4b3c1", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 96.5184268427, "max_line_length": 114172, "alphanum_fraction": 0.7568195224, "converted": true, "num_tokens": 6842, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.3140505514119072, "lm_q1q2_score": 0.14967010220824176}}
{"text": "```python\n\"\"\"Tutorial: Introduction to the Spin-Orbital Formulation of Post-HF Methods\"\"\"\n\n__author__ = \"Adam S. Abbott\"\n__credit__ = [\"Adam S. Abbott\", \"Justin M. Turney\"]\n\n__copyright__ = \"(c) 2014-2017, The Psi4NumPy Developers\"\n__license__ = \"BSD-3-Clause\"\n__date__ = \"2017-05-23\"\n```\n\n# Introduction to the Spin Orbital Formulation of Post-HF Methods\n## Notation\n\nPost-HF methods such as MPn, coupled cluster theory, and configuration interaction improve the accuracy of our Hartree-Fock wavefunction by including terms corresponding to excitations of electrons from occupied (i, j, k..) to virtual (a, b, c...) orbitals. This recovers some of the dynamic electron correlation previously neglected by Hartree-Fock.\n\nIt is convenient to introduce new notation to succinctly express the complex mathematical expressions encountered in these methods. This tutorial will cover this notation and apply it to a spin orbital formulation of conventional MP2. This code will also serve as a starting template for other tutorials which use a spin-orbital formulation, such as CEPA0, CCD, CIS, and OMP2. \n\n\n\n### I. Physicist's Notation for Two-Electron Integrals\nRecall from previous tutorials the form for the two-electron integrals over spin orbitals ($\\chi$) and spatial orbitals ($\\phi$):\n\\begin{equation}\n [pq|rs] = [\\chi_p\\chi_q|\\chi_r\\chi_s] = \\int dx_{1}dx_2 \\space \\chi^*_p(x_1)\\chi_q(x_1)\\frac{1}{r_{12}}\\chi^*_r(x_2)\\chi_s(x_2) \\\\\n(pq|rs) = (\\phi_p\\phi_q|\\phi_r\\phi_s) = \\int dx_{1}dx_2 \\space \\phi^*_p(x_1)\\phi_q(x_1)\\frac{1}{r_{12}}\\phi^*_r(x_2)\\phi_s(x_2)\n\\end{equation}\n\nAnother form of the spin orbital two electron integrals is known as physicist's notation. By grouping the complex conjugates on the left side, we may express them in Dirac (\"bra-ket\") notation:\n\\begin{equation}\n\\langle pq \\mid rs \\rangle = \\langle \\chi_p \\chi_q \\mid \\chi_r \\chi_s \\rangle = \\int dx_{1}dx_2 \\space \\chi^*_p(x_1)\\chi^*_q(x_2)\\frac{1} {r_{12}}\\chi_r(x_1)\\chi_s(x_2) \n\\end{equation}\n\nThe antisymmetric form of the two-electron integrals in physcist's notation is given by\n\n\\begin{equation}\n\\langle pq \\mid\\mid rs \\rangle = \\langle pq \\mid rs \\rangle - \\langle pq \\mid sr \\rangle\n\\end{equation}\n\n\n### II. Kutzelnigg-Mukherjee Tensor Notation and the Einstein Summation Convention\n\nKutzelnigg-Mukherjee (KM) notation provides an easy way to express and manipulate the tensors (two-electron integrals, $t$-amplitudes, CI coefficients, etc.) encountered in post-HF methods. Indices which appear in the bra are expressed as subscripts, and indices which appear in the ket are expressed as superscripts:\n\\begin{equation}\ng_{pq}^{rs} = \\langle pq \\mid rs \\rangle \\quad \\quad \\quad \\overline{g}_{pq}^{rs} = \\langle pq \\mid\\mid rs \\rangle\n\\end{equation}\n\nThe upper and lower indices allow the use of the Einstein Summation convention. Under this convention, whenever an indice appears in both the upper and lower position in a product, that indice is implicitly summed over. As an example, consider the MP2 energy expression:\n\n\\begin{equation}\nE_{MP2} = \\frac{1}{4} \\sum_{i a j b} \\frac{ [ia \\mid\\mid jb] [ia \\mid\\mid jb]} {\\epsilon_i - \\epsilon_a + \\epsilon_j - \\epsilon_b}\n\\end{equation}\nConverting to physicist's notation:\n\n\\begin{equation}\nE_{MP2} = \\frac{1}{4} \\sum_{i j a b} \\frac{ \\langle ij \\mid\\mid ab \\rangle \\langle ij \\mid \\mid ab \\rangle} {\\epsilon_i - \\epsilon_a + \\epsilon_j - \\epsilon_b}\n\\end{equation}\nKM Notation, taking advantage of the permutational symmetry of $g$:\n\\begin{equation}\nE_{MP2} = \\frac{1}{4} \\overline{g}_{ab}^{ij} \\overline{g}_{ij}^{ab} (\\mathcal{E}_{ab}^{ij})^{-1}\n\\end{equation}\n\nwhere $\\mathcal{E}_{ab}^{ij}$ is the sum of orbital energies $\\epsilon_i - \\epsilon_a + \\epsilon_j - \\epsilon_b$. Upon collecting every possible orbital energy sum into a 4-dimensional tensor, this equation can be solved with a simple tensor-contraction, as done in our MP2 tutorial.\n\nThe notation simplication here is minor, but the value of this notation becomes obvious with more complicated expressions encountered in later tutorials such as CCD. It is also worth noting that KM notation is deeply intertwined with the second quantization and diagrammatic expressions of methods in advanced electronic structure theory. For our purposes, we will shy away from the details and simply use the notation to write out readily-programmable expressions.\n\n\n### III. Coding Spin Orbital Methods Example: MP2\n\nIn the MP2 tutorial, we used spatial orbitals in our two-electron integral tensor, and this appreciably decreased the computational cost. However, this code will only work when using an RHF reference wavefunction. We may generalize our MP2 code (and other post-HF methods) to work with any reference by expressing our integrals, MO coefficients, and orbital energies obtained from Hartree-Fock in a spin orbital formulation. As an example, we will code spin orbital MP2, and this will serve as a foundation for later tutorials.\n\n\n\n### Implementation of Spin Orbital MP2\nAs usual, we import Psi4 and NumPy, and set the appropriate options. However, in this code, we will be free to choose open-shell molecules which require UHF or ROHF references. We will stick to RHF and water for now.\n\n\n```python\n# ==> Import statements & Global Options <==\nimport psi4\nimport numpy as np\n\npsi4.set_memory(int(2e9))\nnumpy_memory = 2\npsi4.core.set_output_file('output.dat', False)\n```\n\n\n```python\n# ==> Molecule & Psi4 Options Definitions <==\nmol = psi4.geometry(\"\"\"\n0 1\nO\nH 1 1.1\nH 1 1.1 2 104\nsymmetry c1\n\"\"\")\n\n\npsi4.set_options({'basis': '6-31g',\n 'scf_type': 'pk',\n 'reference': 'rhf',\n 'mp2_type': 'conv',\n 'e_convergence': 1e-8,\n 'd_convergence': 1e-8})\n```\n\nFor convenience, we let Psi4 take care of the Hartree-Fock procedure, and return the wavefunction object.\n\n\n```python\n# Get the SCF wavefunction & energies\nscf_e, scf_wfn = psi4.energy('scf', return_wfn=True)\n```\n\nWe also need information about the basis set and orbitals, such as the number of basis functions, number of spin orbitals, number of alpha and beta electrons, the number of occupied spin orbitals, and the number of virtual spin orbitals. These can be obtained with MintsHelper and from the wavefunction.\n\n\n```python\nmints = psi4.core.MintsHelper(scf_wfn.basisset())\nnbf = mints.nbf()\nnso = 2 * nbf\nnalpha = scf_wfn.nalpha()\nnbeta = scf_wfn.nbeta()\nnocc = nalpha + nbeta\nnvirt = 2 * nbf - nocc\n```\n\nFor MP2, we need the MO coefficients, the two-electron integral tensor, and the orbital energies. But, since we are using spin orbitals, we have to manipulate this data accordingly. Let's get our MO coefficients in the proper form first. Recall in restricted Hartree-Fock, we obtain one MO coefficient matrix **C**, whose columns are the molecular orbital coefficients, and each row corresponds to a different atomic orbital basis function. But, in unrestricted Hartree-Fock, we obtain separate matrices for the alpha and beta spins, **Ca** and **Cb**. We need a general way to build one **C** matrix regardless of our Hartree-Fock reference. The solution is to put alpha and beta MO coefficients into a block diagonal form:\n\n\n```python\nCa = np.asarray(scf_wfn.Ca())\nCb = np.asarray(scf_wfn.Cb())\nC = np.block([\n [ Ca , np.zeros_like(Cb) ],\n [np.zeros_like(Ca) , Cb ]\n ])\n\n# Result: | Ca 0 |\n# | 0 Cb|\n\n```\n\nIt's worth noting that for RHF and ROHF, the Ca and Cb given by Psi4 are the same.\n\nNow, for this version of MP2, we also need the MO-transformed two-electron integral tensor in physicist's notation. However, Psi4's default two-electron integral tensor is in the AO-basis, is not \"spin-blocked\" (like **C**, above!), and is in chemist's notation, so we have a bit of work to do. \n\nFirst, we will spin-block the two electron integral tensor in the same way that we spin-blocked our MO coefficients above. Unfortunately, this transformation is impossible to visualize for a 4-dimensional array.\n\nNevertheless, the math generalizes and can easily be achieved with NumPy's kronecker product function `np.kron`. Here, we take the 2x2 identity, and place the two electron integral array into the space of the 1's along the diagonal. Then, we transpose the result and do the same. The result doubles the size of each dimension, and we obtain a \"spin-blocked\" two electron integral array.\n\n\n```python\n# Get the two electron integrals using MintsHelper\nI = np.asarray(mints.ao_eri())\n\ndef spin_block_tei(I):\n \"\"\" \n Function that spin blocks two-electron integrals\n Using np.kron, we project I into the space of the 2x2 identity, tranpose the result\n and project into the space of the 2x2 identity again. This doubles the size of each axis.\n The result is our two electron integral tensor in the spin orbital form.\n \"\"\"\n identity = np.eye(2)\n I = np.kron(identity, I)\n return np.kron(identity, I.T)\n\n# Spin-block the two electron integral array\nI_spinblock = spin_block_tei(I)\n\n```\n\nFrom here, converting to antisymmetrized physicists notation is simply:\n\n\n```python\n# Converts chemist's notation to physicist's notation, and antisymmetrize\n# (pq | rs) ---> \n# Physicist's notation\ntmp = I_spinblock.transpose(0, 2, 1, 3)\n# Antisymmetrize:\n# = - \ngao = tmp - tmp.transpose(0, 1, 3, 2)\n\n```\n\nWe also need the orbital energies, and just as with the MO coefficients, we combine alpha and beta together. We also want to ensure that the columns of **C** are sorted in the same order as the corresponding orbital energies.\n\n\n```python\n# Get orbital energies \neps_a = np.asarray(scf_wfn.epsilon_a())\neps_b = np.asarray(scf_wfn.epsilon_b())\neps = np.append(eps_a, eps_b)\n\n# Before sorting the orbital energies, we can use their current arrangement to sort the columns\n# of C. Currently, each element i of eps corresponds to the column i of C, but we want both\n# eps and columns of C to be in increasing order of orbital energies\n\n# Sort the columns of C according to the order of increasing orbital energies \nC = C[:, eps.argsort()] \n\n# Sort orbital energies in increasing order\neps = np.sort(eps) \n\n```\n\nFinally, we transform our two-electron integrals to the MO basis. For the sake of generalizing for other methods, instead of just transforming the MP2 relevant subsection as before:\n~~~python\ntmp = np.einsum('pi,pqrs->iqrs', Cocc, I)\ntmp = np.einsum('qa,iqrs->iars', Cvirt, tmp)\ntmp = np.einsum('iars,rj->iajs', tmp, Cocc)\nI_mo = np.einsum('iajs,sb->iajb', tmp, Cvirt)\n~~~\n\nwe instead transform the full array so it can be used for terms from methods other than MP2. The nested `einsum`'s work the same way as the method above. Here, we denote the integrals as `gmo` to differentiate from the chemist's notation integrals `I_mo`.\n\n\n```python\n# Transform gao, which is the spin-blocked 4d array of physicist's notation, \n# antisymmetric two-electron integrals, into the MO basis using MO coefficients \ngmo = np.einsum('pQRS, pP -> PQRS',\n np.einsum('pqRS, qQ -> pQRS',\n np.einsum('pqrS, rR -> pqRS',\n np.einsum('pqrs, sS -> pqrS', gao, C), C), C), C)\n\n```\n\nAnd just as before, construct the 4-dimensional array of orbital energy denominators. An alternative to the old method:\n~~~python\ne_ij = eps[:nocc]\ne_ab = eps[nocc:]\ne_denom = 1 / (e_ij.reshape(-1, 1, 1, 1) - e_ab.reshape(-1, 1, 1) + e_ij.reshape(-1, 1) - e_ab)\n~~~\nis the following:\n\n\n```python\n# Define slices, create 4 dimensional orbital energy denominator tensor\nn = np.newaxis\no = slice(None, nocc)\nv = slice(nocc, None)\ne_abij = 1 / (-eps[v, n, n, n] - eps[n, v, n, n] + eps[n, n, o, n] + eps[n, n, n, o])\n```\n\nThese slices will also be used to define the occupied and virtual space of our two electron integrals. \n\nFor example, $\\bar{g}_{ab}^{ij}$ can be accessed with `gmo[v, v, o, o]` \n\nWe now have all the pieces we need to compute the MP2 correlation energy. Our energy expression in KM notation is\n\n\\begin{equation}\nE_{MP2} = \\frac{1}{4} \\bar{g}_{ab}^{ij} \\bar{g}_{ij}^{ab} (\\mathcal{E}_{ab}^{ij})^{-1}\n\\end{equation}\n\nwhich may be easily read-off as an einsum in NumPy. Here, for clarity, we choose to read the tensors from left to right (bra to ket). We also are sure to take the appropriate slice of the two-electron integral array:\n\n\n```python\n# Compute MP2 Correlation Energy\nE_MP2_corr = (1 / 4) * np.einsum('abij, ijab, abij ->', gmo[v, v, o, o], gmo[o, o, v, v], e_abij)\n\nE_MP2 = E_MP2_corr + scf_e\n\nprint('MP2 correlation energy: ', E_MP2_corr)\nprint('MP2 total energy: ', E_MP2)\n```\n\n MP2 correlation energy: -0.142119840297\n MP2 total energy: -76.094648885\n\n\nFinally, compare our answer with Psi4:\n\n\n```python\n# ==> Compare to Psi4 <==\npsi4.driver.p4util.compare_values(psi4.energy('mp2'), E_MP2, 6, 'MP2 Energy')\n```\n\n \tMP2 Energy........................................................PASSED\n\n\n\n\n\n True\n\n\n\n## References\n\n1. Notation and Symmetry of Integrals:\n > C. David Sherill, \"Permutational Symmetries of One- and Two-Electron Integrals\" Accessed with http://vergil.chemistry.gatech.edu/notes/permsymm/permsymm.pdf\n2. Useful Notes on Kutzelnigg-Mukherjee Notation: \n > A. V. Copan, \"Kutzelnigg-Mukherjee Tensor Notation\" Accessed with https://github.com/CCQC/chem-8950/tree/master/2017\n\n3. Original paper on MP2: \"Note on an Approximation Treatment for Many-Electron Systems\"\n\t> [[Moller:1934:618](https://journals.aps.org/pr/abstract/10.1103/PhysRev.46.618)] C. Møller and M. S. Plesset, *Phys. Rev.* **46**, 618 (1934)\n \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "823f207dc56d5b2a4d708d0e922272438cc93dce", "size": 19530, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Tutorials/08_CEPA0_and_CCD/8a_Intro_to_spin_orbital_postHF.ipynb", "max_stars_repo_name": "loriab/psi4numpy", "max_stars_repo_head_hexsha": "01e5adec766549aeaf9a1c71bbe4129b3b3515d0", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Tutorials/08_CEPA0_and_CCD/8a_Intro_to_spin_orbital_postHF.ipynb", "max_issues_repo_name": "loriab/psi4numpy", "max_issues_repo_head_hexsha": "01e5adec766549aeaf9a1c71bbe4129b3b3515d0", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Tutorials/08_CEPA0_and_CCD/8a_Intro_to_spin_orbital_postHF.ipynb", "max_forks_repo_name": "loriab/psi4numpy", "max_forks_repo_head_hexsha": "01e5adec766549aeaf9a1c71bbe4129b3b3515d0", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.8270377734, "max_line_length": 730, "alphanum_fraction": 0.6032770097, "converted": true, "num_tokens": 3822, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.3140505385717077, "lm_q1q2_score": 0.149670096088864}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n print(f\"heads: {heads}, {N}\")\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\n\n```python\nx = np.linspace(0, 1, 100)\nplt.plot(x, dist.pdf(x, 10, 100))\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\n```\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\n /Users/jasonbenn/.pyenv/versions/3.6.4/envs/bayesian-methods-for-hackers/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n from ._conv import register_converters as _register_converters\n\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n Multiprocess sampling (4 chains in 4 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2_log__]\n >Metropolis: [lambda_1_log__]\n 77%|███████▋ | 11610/15000 [00:06<00:01, 1713.06it/s]INFO (theano.gof.compilelock): Waiting for existing lock by process '12092' (I am process '12093')\n INFO (theano.gof.compilelock): To manually release the lock, delete /Users/jasonbenn/.theano/compiledir_Darwin-17.4.0-x86_64-i386-64bit-i386-3.6.4-64/lock_dir\n 80%|████████ | 12012/15000 [00:06<00:01, 1716.64it/s]INFO (theano.gof.compilelock): Waiting for existing lock by process '12092' (I am process '12094')\n INFO (theano.gof.compilelock): To manually release the lock, delete /Users/jasonbenn/.theano/compiledir_Darwin-17.4.0-x86_64-i386-64bit-i386-3.6.4-64/lock_dir\n 100%|██████████| 15000/15000 [00:08<00:00, 1753.79it/s]\n INFO (theano.gof.compilelock): Waiting for existing lock by process '12093' (I am process '12094')\n INFO (theano.gof.compilelock): To manually release the lock, delete /Users/jasonbenn/.theano/compiledir_Darwin-17.4.0-x86_64-i386-64bit-i386-3.6.4-64/lock_dir\n The estimated number of effective samples is smaller than 200 for some parameters.\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\nprint(lambda_1_samples.mean())\nprint(lambda_2_samples.mean())\n```\n\n 17.81079852458376\n 22.505799206019486\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\nnp.mean(lambda_1_samples/lambda_2_samples)\n```\n\n\n\n\n 0.7994063505697679\n\n\n\n\n```python\nlambda_1_samples.mean()/lambda_2_samples.mean()\n```\n\n\n\n\n 0.7913870714628973\n\n\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\nlambda_1_samples[tau_samples < 45].mean()\n```\n\n\n\n\n 17.75357924652044\n\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "123e086993d322ae83355228c99dbdd509aee556", "size": 400254, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "JasonBenn/bayesian-methods-for-hackers", "max_stars_repo_head_hexsha": "954f4b53bc953748b72b71e5793d08ee35056303", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "JasonBenn/bayesian-methods-for-hackers", "max_issues_repo_head_hexsha": "954f4b53bc953748b72b71e5793d08ee35056303", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "JasonBenn/bayesian-methods-for-hackers", "max_forks_repo_head_hexsha": "954f4b53bc953748b72b71e5793d08ee35056303", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 319.6916932907, "max_line_length": 88804, "alphanum_fraction": 0.9106217552, "converted": true, "num_tokens": 12386, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.3040416623541848, "lm_q1q2_score": 0.1496456989755578}}
{"text": "\n# PHY321: Motion examples, Forces, Newton's Laws and Motion Example\n\n \n**[Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/)**, Department of Physics and Astronomy and Facility for Rare Ion Beams (FRIB), Michigan State University, USA and Department of Physics, University of Oslo, Norway\n\nDate: **Jan 25, 2021**\n\nCopyright 1999-2021, [Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/). Released under CC Attribution-NonCommercial 4.0 license\n\n\n\n\n## Aims and Overarching Motivation\n\n### Monday\n\nWe try to finalize the discussion we started last Friday on falling objects and numerical aspects thereof.\nIf we get time, we start with a discussion of forces as well.\n\nRecommended reading: Taylor 1.3\n\n### Wednesday\n\nWe revisit Newton's laws and discuss how to analyze a problem.\n\nRecommended reading: Taylor 1.4 and 1.5\n\n### Friday\n\nWe discuss several examples and try to wrap up the discussions on Newton's laws.\n\nRecommended reading: Taylor 1.4-1.6 and 2.1-2.2 as examples of motion problems.\n\n\n\n## Basic Steps of Scientific Investigations\n\nLast week we discussed several basi elements of the scientific method. We repeat them here.\n\nAn overarching aim in this course is to give you a deeper\nunderstanding of the scientific method. The problems we study will all\ninvolve cases where we can apply classical mechanics. In our previous\nmaterial we already assumed that we had a model for the motion of an\nobject. Alternatively we could have data from experiment (like Usain\nBolt's 100m world record run in 2008). Or we could have performed\nourselves an experiment and we want to understand which forces are at\nplay and whether these forces can be understood in terms of\nfundamental forces.\n\nOur first step consists in identifying the problem. What we sketch\nhere may include a mix of experiment and theoretical simulations, or\njust experiment or only theory.\n\n## Identifying our System\n\nHere we can ask questions like\n1. What kind of object is moving\n\n2. What kind of data do we have\n\n3. How do we measure position, velocity, acceleration etc\n\n4. Which initial conditions influence our system\n\n5. Other aspects which allow us to identify the system\n\n## Defining a Model\n\nWith our eventual data and observations we would now like to develop a\nmodel for the system. In the end we want obviously to be able to\nunderstand which forces are at play and how they influence our\nspecific system. That is, can we extract some deeper insights about a\nsystem?\n\nWe need then to\n1. Find the forces that act on our system\n\n2. Introduce models for the forces\n\n3. Identify the equations which can govern the system (Newton's second law for example)\n\n4. More elements we deem important for defining our model\n\n## Solving the Equations\n\nWith the model at hand, we can then solve the equations. In classical mechanics we normally end up with solving sets of coupled ordinary differential equations or partial differential equations.\n1. Using Newton's second law we have equations of the type $\\boldsymbol{F}=m\\boldsymbol{a}=md\\boldsymbol{v}/dt$\n\n2. We need to define the initial conditions (typically the initial velocity and position as functions of time) and/or initial conditions and boundary conditions\n\n3. The solution of the equations give us then the position, the velocity and other time-dependent quantities which may specify the motion of a given object.\n\nWe are not yet done. With our lovely solvers, we need to start thinking.\n\n## Analyze\n\nNow it is time to ask the big questions. What do our results mean? Can we give a simple interpretation in terms of fundamental laws? What do our results mean? Are they correct?\nThus, typical questions we may ask are\n1. Are our results for say $\\boldsymbol{r}(t)$ valid? Do we trust what we did? Can you validate and verify the correctness of your results?\n\n2. Evaluate the answers and their implications\n\n3. Compare with experimental data if possible. Does our model make sense?\n\n4. and obviously many other questions.\n\nThe analysis stage feeds back to the first stage. It may happen that\nthe data we had were not good enough, there could be large statistical\nuncertainties. We may need to collect more data or perhaps we did a\nsloppy job in identifying the degrees of freedom.\n\nAll these steps are essential elements in a scientific\nenquiry. Hopefully, through a mix of numerical simulations, analytical\ncalculations and experiments we may gain a deeper insight about the\nphysics of a specific system.\n\n\n## Falling baseball in one dimension\n\nWe anticipate the mathematical model to come and assume that we have a\nmodel for the motion of a falling baseball without air resistance.\nOur system (the baseball) is at an initial height $y_0$ (which we will\nspecify in the program below) at the initial time $t_0=0$. In our program example here we will plot the position in steps of $\\Delta t$ up to a final time $t_f$. \nThe mathematical formula for the position $y(t)$ as function of time $t$ is\n\n$$\ny(t) = y_0-\\frac{1}{2}gt^2,\n$$\n\nwhere $g=9.80665=0.980655\\times 10^1$m/s${}^2$ is a constant representing the standard acceleration due to gravity.\nWe have here adopted the conventional standard value. This does not take into account other effects, such as buoyancy or drag.\nFurthermore, we stop when the ball hits the ground, which takes place at\n\n$$\ny(t) = 0= y_0-\\frac{1}{2}gt^2,\n$$\n\nwhich gives us a final time $t_f=\\sqrt{2y_0/g}$. \n\nAs of now we simply assume that we know the formula for the falling object. Afterwards, we will derive it.\n\n## Our Python Encounter\n\nWe start with preparing folders for storing our calculations, figures and if needed, specific data files we use as input or output files.\n\n\n```python\n%matplotlib inline\n\n# Common imports\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n#in case we have an input file we wish to read in\n#infile = open(data_path(\"MassEval2016.dat\"),'r')\n```\n\nYou could also define a function for making our plots. You\ncan obviously avoid this and simply set up various **matplotlib**\ncommands every time you need them. You may however find it convenient\nto collect all such commands in one function and simply call this\nfunction.\n\n\n```python\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\ndef MakePlot(x,y, styles, labels, axlabels):\n plt.figure(figsize=(10,6))\n for i in range(len(x)):\n plt.plot(x[i], y[i], styles[i], label = labels[i])\n plt.xlabel(axlabels[0])\n plt.ylabel(axlabels[1])\n plt.legend(loc=0)\n```\n\nThereafter we start setting up the code for the falling object.\n\n\n```python\n%matplotlib inline\nimport matplotlib.patches as mpatches\n\ng = 9.80655 #m/s^2\ny_0 = 10.0 # initial position in meters\nDeltaT = 0.1 # time step\n# final time when y = 0, t = sqrt(2*10/g)\ntfinal = np.sqrt(2.0*y_0/g)\n#set up arrays \nt = np.arange(0,tfinal,DeltaT)\ny =y_0 -g*.5*t**2\n# Then make a nice printout in table form using Pandas\nimport pandas as pd\nfrom IPython.display import display\ndata = {'t[s]': t,\n 'y[m]': y\n }\nRawData = pd.DataFrame(data)\ndisplay(RawData)\nplt.style.use('ggplot')\nplt.figure(figsize=(8,8))\nplt.scatter(t, y, color = 'b')\nblue_patch = mpatches.Patch(color = 'b', label = 'Height y as function of time t')\nplt.legend(handles=[blue_patch])\nplt.xlabel(\"t[s]\")\nplt.ylabel(\"y[m]\")\nsave_fig(\"FallingBaseball\")\nplt.show()\n```\n\nHere we used **pandas** (see below) to systemize the output of the position as function of time.\n\n\n## Average quantities\nWe define now the average velocity as\n\n$$\n\\overline{v}(t) = \\frac{y(t+\\Delta t)-y(t)}{\\Delta t}.\n$$\n\nIn the code we have set the time step $\\Delta t$ to a given value. We could define it in terms of the number of points $n$ as\n\n$$\n\\Delta t = \\frac{t_{\\mathrm{final}-}t_{\\mathrm{initial}}}{n+1}.\n$$\n\nSince we have discretized the variables, we introduce the counter $i$ and let $y(t)\\rightarrow y(t_i)=y_i$ and $t\\rightarrow t_i$\nwith $i=0,1,\\dots, n$. This gives us the following shorthand notations that we will use for the rest of this course. We define\n\n$$\ny_i = y(t_i),\\hspace{0.2cm} i=0,1,2,\\dots,n.\n$$\n\nThis applies to other variables which depend on say time. Examples are the velocities, accelerations, momenta etc.\nFurthermore we use the shorthand\n\n$$\ny_{i\\pm 1} = y(t_i\\pm \\Delta t),\\hspace{0.12cm} i=0,1,2,\\dots,n.\n$$\n\n## Compact equations\nWe can then rewrite in a more compact form the average velocity as\n\n$$\n\\overline{v}_i = \\frac{y_{i+1}-y_{i}}{\\Delta t}.\n$$\n\nThe velocity is defined as the change in position per unit time.\nIn the limit $\\Delta t \\rightarrow 0$ this defines the instantaneous velocity, which is nothing but the slope of the position at a time $t$.\nWe have thus\n\n$$\nv(t) = \\frac{dy}{dt}=\\lim_{\\Delta t \\rightarrow 0}\\frac{y(t+\\Delta t)-y(t)}{\\Delta t}.\n$$\n\nSimilarly, we can define the average acceleration as the change in velocity per unit time as\n\n$$\n\\overline{a}_i = \\frac{v_{i+1}-v_{i}}{\\Delta t},\n$$\n\nresulting in the instantaneous acceleration\n\n$$\na(t) = \\frac{dv}{dt}=\\lim_{\\Delta t\\rightarrow 0}\\frac{v(t+\\Delta t)-v(t)}{\\Delta t}.\n$$\n\n**A note on notations**: When writing for example the velocity as $v(t)$ we are then referring to the continuous and instantaneous value. A subscript like\n$v_i$ refers always to the discretized values.\n\n## A differential equation\nWe can rewrite the instantaneous acceleration as\n\n$$\na(t) = \\frac{dv}{dt}=\\frac{d}{dt}\\frac{dy}{dt}=\\frac{d^2y}{dt^2}.\n$$\n\nThis forms the starting point for our definition of forces later. It is a famous second-order differential equation. If the acceleration is constant we can now recover the formula for the falling ball we started with.\nThe acceleration can depend on the position and the velocity. To be more formal we should then write the above differential equation as\n\n$$\n\\frac{d^2y}{dt^2}=a(t,y(t),\\frac{dy}{dt}).\n$$\n\nWith given initial conditions for $y(t_0)$ and $v(t_0)$ we can then\nintegrate the above equation and find the velocities and positions at\na given time $t$.\n\nIf we multiply with mass, we have one of the famous expressions for Newton's second law,\n\n$$\nF(y,v,t)=m\\frac{d^2y}{dt^2}=ma(t,y(t),\\frac{dy}{dt}),\n$$\n\nwhere $F$ is the force acting on an object with mass $m$. We see that it also has the right dimension, mass times length divided by time squared.\nWe will come back to this soon.\n\n## Integrating our equations\n\nFormally we can then, starting with the acceleration (suppose we have measured it, how could we do that?)\ncompute say the height of a building. To see this we perform the following integrations from an initial time $t_0$ to a given time $t$\n\n$$\n\\int_{t_0}^t dt a(t) = \\int_{t_0}^t dt \\frac{dv}{dt} = v(t)-v(t_0),\n$$\n\nor as\n\n$$\nv(t)=v(t_0)+\\int_{t_0}^t dt a(t).\n$$\n\nWhen we know the velocity as function of time, we can find the position as function of time starting from the defintion of velocity as the derivative with respect to time, that is we have\n\n$$\n\\int_{t_0}^t dt v(t) = \\int_{t_0}^t dt \\frac{dy}{dt} = y(t)-y(t_0),\n$$\n\nor as\n\n$$\ny(t)=y(t_0)+\\int_{t_0}^t dt v(t).\n$$\n\nThese equations define what is called the integration method for\nfinding the position and the velocity as functions of time. There is\nno loss of generality if we extend these equations to more than one\nspatial dimension.\n\n## Constant acceleration case, the velocity\nLet us compute the velocity using the constant value for the acceleration given by $-g$. We have\n\n$$\nv(t)=v(t_0)+\\int_{t_0}^t dt a(t)=v(t_0)+\\int_{t_0}^t dt (-g).\n$$\n\nUsing our initial time as $t_0=0$s and setting the initial velocity $v(t_0)=v_0=0$m/s we get when integrating\n\n$$\nv(t)=-gt.\n$$\n\nThe more general case is\n\n$$\nv(t)=v_0-g(t-t_0).\n$$\n\nWe can then integrate the velocity and obtain the final formula for the position as function of time through\n\n$$\ny(t)=y(t_0)+\\int_{t_0}^t dt v(t)=y_0+\\int_{t_0}^t dt v(t)=y_0+\\int_{t_0}^t dt (-gt),\n$$\n\nWith $y_0=10$m and $t_0=0$s, we obtain the equation we started with\n\n$$\ny(t)=10-\\frac{1}{2}gt^2.\n$$\n\n## Computing the averages\nAfter this mathematical background we are now ready to compute the mean velocity using our data.\n\n\n```python\n# Now we can compute the mean velocity using our data\n# We define first an array Vaverage\nn = np.size(t)\nVaverage = np.zeros(n)\nfor i in range(1,n-1):\n Vaverage[i] = (y[i+1]-y[i])/DeltaT\n# Now we can compute the mean accelearatio using our data\n# We define first an array Aaverage\nn = np.size(t)\nAaverage = np.zeros(n)\nAaverage[0] = -g\nfor i in range(1,n-1):\n Aaverage[i] = (Vaverage[i+1]-Vaverage[i])/DeltaT\ndata = {'t[s]': t,\n 'y[m]': y,\n 'v[m/s]': Vaverage,\n 'a[m/s^2]': Aaverage\n }\nNewData = pd.DataFrame(data)\ndisplay(NewData[0:n-2])\n```\n\nNote that we don't print the last values! \n\n\n\n## Including Air Resistance in our model\n\nIn our discussions till now of the falling baseball, we have ignored\nair resistance and simply assumed that our system is only influenced\nby the gravitational force. We will postpone the derivation of air\nresistance till later, after our discussion of Newton's laws and\nforces.\n\nFor our discussions here it suffices to state that the accelerations is now modified to\n\n$$\n\\boldsymbol{a}(t) = -g +D\\boldsymbol{v}(t)\\vert v(t)\\vert,\n$$\n\nwhere $\\vert v(t)\\vert$ is the absolute value of the velocity and $D$ is a constant which pertains to the specific object we are studying.\nSince we are dealing with motion in one dimension, we can simplify the above to\n\n$$\na(t) = -g +Dv^2(t).\n$$\n\nWe can rewrite this as a differential equation\n\n$$\na(t) = \\frac{dv}{dt}=\\frac{d^2y}{dt^2}= -g +Dv^2(t).\n$$\n\nUsing the integral equations discussed above we can integrate twice\nand obtain first the velocity as function of time and thereafter the\nposition as function of time.\n\nFor this particular case, we can actually obtain an analytical\nsolution for the velocity and for the position. Here we will first\ncompute the solutions analytically, thereafter we will derive Euler's\nmethod for solving these differential equations numerically.\n\n## Analytical solutions\n\nFor simplicity let us just write $v(t)$ as $v$. We have\n\n$$\n\\frac{dv}{dt}= -g +Dv^2(t).\n$$\n\nWe can solve this using the technique of separation of variables. We\nisolate on the left all terms that involve $v$ and on the right all\nterms that involve time. We get then\n\n$$\n\\frac{dv}{g -Dv^2(t) }= -dt,\n$$\n\nWe scale now the equation to the left by introducing a constant\n$v_T=\\sqrt{g/D}$. This constant has dimension length/time. Can you\nshow this?\n\nNext we integrate the left-hand side (lhs) from $v_0=0$ m/s to $v$ and\nthe right-hand side (rhs) from $t_0=0$ to $t$ and obtain\n\n$$\n\\int_{0}^v\\frac{dv}{g -Dv^2(t) }= \\frac{v_T}{g}\\mathrm{arctanh}(\\frac{v}{v_T}) =-\\int_0^tdt = -t.\n$$\n\nWe can reorganize these equations as\n\n$$\nv_T\\mathrm{arctanh}(\\frac{v}{v_T}) =-gt,\n$$\n\nwhich gives us $v$ as function of time\n\n$$\nv(t)=v_T\\tanh{-(\\frac{gt}{v_T})}.\n$$\n\n## Finding the final height\nWith the velocity we can then find the height $y(t)$ by integrating yet another time, that is\n\n$$\ny(t)=y(t_0)+\\int_{t_0}^t dt v(t)=\\int_{0}^t dt[v_T\\tanh{-(\\frac{gt}{v_T})}].\n$$\n\nThis integral is a little bit trickier but we can look it up in a table over \nknown integrals and we get\n\n$$\ny(t)=y(t_0)-\\frac{v_T^2}{g}\\log{[\\cosh{(\\frac{gt}{v_T})}]}.\n$$\n\nAlternatively we could have used the symbolic Python package **Sympy**.\n\nIn most cases however, we need to revert to numerical solutions. \n\n\n## Our first attempt at solving differential equations\n\nHere we will try the simplest possible approach to solving the second-order differential \nequation\n\n$$\na(t) =\\frac{d^2y}{dt^2}= -g +Dv^2(t).\n$$\n\nWe rewrite it as two coupled first-order equations (this is a standard approach)\n\n$$\n\\frac{dy}{dt} = v(t),\n$$\n\nwith initial condition $y(t_0)=y_0$ and\n\n$$\na(t) =\\frac{dv}{dt}= -g +Dv^2(t),\n$$\n\nwith initial condition $v(t_0)=v_0$.\n\nMany of the algorithms for solving differential equations start with simple Taylor equations.\nIf we now Taylor expand $y$ and $v$ around a value $t+\\Delta t$ we have\n\n$$\ny(t+\\Delta t) = y(t)+\\Delta t \\frac{dy}{dt}+\\frac{\\Delta t^2}{2!} \\frac{d^2y}{dt^2}+O(\\Delta t^3),\n$$\n\nand\n\n$$\nv(t+\\Delta t) = v(t)+\\Delta t \\frac{dv}{dt}+\\frac{\\Delta t^2}{2!} \\frac{d^2v}{dt^2}+O(\\Delta t^3).\n$$\n\nUsing the fact that $dy/dt = v$ and $dv/dt=a$ and keeping only terms up to $\\Delta t$ we have\n\n$$\ny(t+\\Delta t) = y(t)+\\Delta t v(t)+O(\\Delta t^2),\n$$\n\nand\n\n$$\nv(t+\\Delta t) = v(t)+\\Delta t a(t)+O(\\Delta t^2).\n$$\n\n## Discretizing our equations\n\nUsing our discretized versions of the equations with for example\n$y_{i}=y(t_i)$ and $y_{i\\pm 1}=y(t_i+\\Delta t)$, we can rewrite the\nabove equations as (and truncating at $\\Delta t$)\n\n$$\ny_{i+1} = y_i+\\Delta t v_i,\n$$\n\nand\n\n$$\nv_{i+1} = v_i+\\Delta t a_i.\n$$\n\nThese are the famous Euler equations (forward Euler).\n\nTo solve these equations numerically we start at a time $t_0$ and simply integrate up these equations to a final time $t_f$,\nThe step size $\\Delta t$ is an input parameter in our code.\nYou can define it directly in the code below as\n\n\n```python\nDeltaT = 0.1\n```\n\nWith a given final time **tfinal** we can then find the number of integration points via the **ceil** function included in the **math** package of Python\nas\n\n\n```python\n#define final time, assuming that initial time is zero\nfrom math import ceil\ntfinal = 0.5\nn = ceil(tfinal/DeltaT)\nprint(n)\n```\n\nThe **ceil** function returns the smallest integer not less than the input in say\n\n\n```python\nx = 21.15\nprint(ceil(x))\n```\n\nwhich in the case here is 22.\n\n\n```python\nx = 21.75\nprint(ceil(x))\n```\n\nwhich also yields 22. The **floor** function in the **math** package\nis used to return the closest integer value which is less than or equal to the specified expression or value.\nCompare the previous result to the usage of **floor**\n\n\n```python\nfrom math import floor\nx = 21.75\nprint(floor(x))\n```\n\nAlternatively, we can define ourselves the number of integration(mesh) points. In this case we could have\n\n\n```python\nn = 10\ntinitial = 0.0\ntfinal = 0.5\nDeltaT = (tfinal-tinitial)/(n)\nprint(DeltaT)\n```\n\nSince we will set up one-dimensional arrays that contain the values of\nvarious variables like time, position, velocity, acceleration etc, we\nneed to know the value of $n$, the number of data points (or\nintegration or mesh points). With $n$ we can initialize a given array\nby setting all elelements to zero, as done here\n\n\n```python\n# define array a\na = np.zeros(n)\nprint(a)\n```\n\n## Code for implementing Euler's method\nIn the code here we implement this simple Eurler scheme choosing a value for $D=0.0245$ m/s.\n\n\n```python\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\ng = 9.80655 #m/s^2\nD = 0.00245 #m/s\nDeltaT = 0.1\n#set up arrays \ntfinal = 0.5\nn = ceil(tfinal/DeltaT)\n# define scaling constant vT\nvT = sqrt(g/D)\n# set up arrays for t, a, v, and y and we can compare our results with analytical ones\nt = np.zeros(n)\na = np.zeros(n)\nv = np.zeros(n)\ny = np.zeros(n)\nyanalytic = np.zeros(n)\n# Initial conditions\nv[0] = 0.0 #m/s\ny[0] = 10.0 #m\nyanalytic[0] = y[0]\n# Start integrating using Euler's method\nfor i in range(n-1):\n # expression for acceleration\n a[i] = -g + D*v[i]*v[i]\n # update velocity and position\n y[i+1] = y[i] + DeltaT*v[i]\n v[i+1] = v[i] + DeltaT*a[i]\n # update time to next time step and compute analytical answer\n t[i+1] = t[i] + DeltaT\n yanalytic[i+1] = y[0]-(vT*vT/g)*log(cosh(g*t[i+1]/vT))\n if ( y[i+1] < 0.0):\n break\na[n-1] = -g + D*v[n-1]*v[n-1]\ndata = {'t[s]': t,\n 'y[m]': y-yanalytic,\n 'v[m/s]': v,\n 'a[m/s^2]': a\n }\nNewData = pd.DataFrame(data)\ndisplay(NewData)\n#finally we plot the data\nfig, axs = plt.subplots(3, 1)\naxs[0].plot(t, y, t, yanalytic)\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y and exact')\naxs[1].plot(t, v)\naxs[1].set_ylabel('v[m/s]')\naxs[2].plot(t, a)\naxs[2].set_xlabel('time[s]')\naxs[2].set_ylabel('a[m/s^2]')\nfig.tight_layout()\nsave_fig(\"EulerIntegration\")\nplt.show()\n```\n\nTry different values for $\\Delta t$ and study the difference between the exact solution and the numerical solution.\n\n## Simple extension, the Euler-Cromer method\n\nThe Euler-Cromer method is a simple variant of the standard Euler\nmethod. We use the newly updated velocity $v_{i+1}$ as an input to the\nnew position, that is, instead of\n\n$$\ny_{i+1} = y_i+\\Delta t v_i,\n$$\n\nand\n\n$$\nv_{i+1} = v_i+\\Delta t a_i,\n$$\n\nwe use now the newly calculate for $v_{i+1}$ as input to $y_{i+1}$, that is \nwe compute first\n\n$$\nv_{i+1} = v_i+\\Delta t a_i,\n$$\n\nand then\n\n$$\ny_{i+1} = y_i+\\Delta t v_{i+1},\n$$\n\nImplementing the Euler-Cromer method yields a simple change to the previous code. We only need to change the following line in the loop over time\nsteps\n\n\n```python\nfor i in range(n-1):\n # more codes in between here\n v[i+1] = v[i] + DeltaT*a[i]\n y[i+1] = y[i] + DeltaT*v[i+1]\n # more code\n```\n\n## Newton's Laws\n\nLet us now remind ourselves of Newton's laws, since these are the laws of motion we will study in this course.\n\n\nWhen analyzing a physical system we normally start with distinguishing between the object we are studying (we will label this in more general terms as our **system**) and how this system interacts with the environment (which often means everything else!)\n\nIn our investigations we will thus analyze a specific physics problem in terms of the system and the environment.\nIn doing so we need to identify the forces that act on the system and assume that the\nforces acting on the system must have a source, an identifiable cause in\nthe environment.\n\nA force acting on for example a falling object must be related to an interaction with something in the environment.\nThis also means that we do not consider internal forces. The latter are forces between\none part of the object and another part. In this course we will mainly focus on external forces.\n\nForces are either contact forces or long-range forces.\n\nContact forces, as evident from the name, are forces that occur at the contact between\nthe system and the environment. Well-known long-range forces are the gravitional force and the electromagnetic force.\n\n\n## Setting up a model for forces acting on an object\n\nIn order to set up the forces which act on an object, the following steps may be useful\n1. Divide the problem into system and environment.\n\n2. Draw a figure of the object and everything in contact with the object.\n\n3. Draw a closed curve around the system.\n\n4. Find contact points—these are the points where contact forces may act.\n\n5. Give names and symbols to all the contact forces.\n\n6. Identify the long-range forces.\n\n7. Make a drawing of the object. Draw the forces as arrows, vectors, starting from where the force is acting. The direction of the vector(s) indicates the (positive) direction of the force. Try to make the length of the arrow indicate the relative magnitude of the forces.\n\n8. Draw in the axes of the coordinate system. It is often convenient to make one axis parallel to the direction of motion. When you choose the direction of the axis you also choose the positive direction for the axis.\n\n## Newton's Laws, the Second one first\n\n\nNewton’s second law of motion: The force $\\boldsymbol{F}$ on an object of inertial mass $m$\nis related to the acceleration a of the object through\n\n$$\n\\boldsymbol{F} = m\\boldsymbol{a},\n$$\n\nwhere $\\boldsymbol{a}$ is the acceleration.\n\nNewton’s laws of motion are laws of nature that have been found by experimental\ninvestigations and have been shown to hold up to continued experimental investigations.\nNewton’s laws are valid over a wide range of length- and time-scales. We\nuse Newton’s laws of motion to describe everything from the motion of atoms to the\nmotion of galaxies.\n\nThe second law is a vector equation with the acceleration having the same\ndirection as the force. The acceleration is proportional to the force via the mass $m$ of the system under study.\n\n\nNewton’s second law introduces a new property of an object, the so-called \ninertial mass $m$. We determine the inertial mass of an object by measuring the\nacceleration for a given applied force.\n\n\n## Then the First Law\n\n\nWhat happens if the net external force on a body is zero? Applying Newton’s second\nlaw, we find:\n\n$$\n\\boldsymbol{F} = 0 = m\\boldsymbol{a},\n$$\n\nwhich gives using the definition of the acceleration\n\n$$\n\\boldsymbol{a} = \\frac{d\\boldsymbol{v}}{dt}=0.\n$$\n\nThe acceleration is zero, which means that the velocity of the object is constant. This\nis often referred to as Newton’s first law. An object in a state of uniform motion tends to remain in\nthat state unless an external force changes its state of motion.\nWhy do we need a separate law for this? Is it not simply a special case of Newton’s\nsecond law? Yes, Newton’s first law can be deduced from the second law as we have\nillustrated. However, the first law is often used for a different purpose: Newton’s\nFirst Law tells us about the limit of applicability of Newton’s Second law. Newton’s\nSecond law can only be used in reference systems where the First law is obeyed. But\nis not the First law always valid? No! The First law is only valid in reference systems\nthat are not accelerated. If you observe the motion of a ball from an accelerating\ncar, the ball will appear to accelerate even if there are no forces acting on it. We call\nsystems that are not accelerating inertial systems, and Newton’s first law is often\ncalled the law of inertia. Newton’s first and second laws of motion are only valid in\ninertial systems. \n\nA system is an inertial system if it is not accelerated. It means that the reference system\nmust not be accelerating linearly or rotating. Unfortunately, this means that most\nsystems we know are not really inertial systems. For example, the surface of the\nEarth is clearly not an inertial system, because the Earth is rotating. The Earth is also\nnot an inertial system, because it ismoving in a curved path around the Sun. However,\neven if the surface of the Earth is not strictly an inertial system, it may be considered\nto be approximately an inertial system for many laboratory-size experiments.\n\n## And finally the Third Law\n\n\nIf there is a force from object A on object B, there is also a force from object B on object A.\nThis fundamental principle of interactions is called Newton’s third law. We do not\nknow of any force that do not obey this law: All forces appear in pairs. Newton’s\nthird law is usually formulated as: For every action there is an equal and opposite\nreaction.\n\n\n## Motion of a Single Object\n\nHere we consider the motion of a single particle moving under\nthe influence of some set of forces. We will consider some problems where\nthe force does not depend on the position. In that case Newton's law\n$m\\dot{\\boldsymbol{v}}=\\boldsymbol{F}(\\boldsymbol{v})$ is a first-order differential\nequation and one solves for $\\boldsymbol{v}(t)$, then moves on to integrate\n$\\boldsymbol{v}$ to get the position. In essentially all of these cases we cna find an analytical solution.\n\n\n## Air Resistance in One Dimension\n\nAir resistance tends to scale as the square of the velocity. This is\nin contrast to many problems chosen for textbooks, where it is linear\nin the velocity. The choice of a linear dependence is motivated by\nmathematical simplicity (it keeps the differential equation linear)\nrather than by physics. One can see that the force should be quadratic\nin velocity by considering the momentum imparted on the air\nmolecules. If an object sweeps through a volume $dV$ of air in time\n$dt$, the momentum imparted on the air is\n\n\n
\n\n$$\n\\begin{equation}\ndP=\\rho_m dV v,\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nwhere $v$ is the velocity of the object and $\\rho_m$ is the mass\ndensity of the air. If the molecules bounce back as opposed to stop\nyou would double the size of the term. The opposite value of the\nmomentum is imparted onto the object itself. Geometrically, the\ndifferential volume is\n\n\n
\n\n$$\n\\begin{equation}\ndV=Avdt,\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nwhere $A$ is the cross-sectional area and $vdt$ is the distance the\nobject moved in time $dt$.\n\n## Resulting Acceleration\nPlugging this into the expression above,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dP}{dt}=-\\rho_m A v^2.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\nThis is the force felt by the particle, and is opposite to its\ndirection of motion. Now, because air doesn't stop when it hits an\nobject, but flows around the best it can, the actual force is reduced\nby a dimensionless factor $c_W$, called the drag coefficient.\n\n\n
\n\n$$\n\\begin{equation}\nF_{\\rm drag}=-c_W\\rho_m Av^2,\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nand the acceleration is\n\n$$\n\\begin{eqnarray}\n\\frac{dv}{dt}=-\\frac{c_W\\rho_mA}{m}v^2.\n\\end{eqnarray}\n$$\n\nFor a particle with initial velocity $v_0$, one can separate the $dt$\nto one side of the equation, and move everything with $v$s to the\nother side. We did this in our discussion of simple motion and will not repeat it here.\n\nOn more general terms,\nfor many systems, e.g. an automobile, there are multiple sources of\nresistance. In addition to wind resistance, where the force is\nproportional to $v^2$, there are dissipative effects of the tires on\nthe pavement, and in the axel and drive train. These other forces can\nhave components that scale proportional to $v$, and components that\nare independent of $v$. Those independent of $v$, e.g. the usual\n$f=\\mu_K N$ frictional force you consider in your first Physics courses, only set in\nonce the object is actually moving. As speeds become higher, the $v^2$\ncomponents begin to dominate relative to the others. For automobiles\nat freeway speeds, the $v^2$ terms are largely responsible for the\nloss of efficiency. To travel a distance $L$ at fixed speed $v$, the\nenergy/work required to overcome the dissipative forces are $fL$,\nwhich for a force of the form $f=\\alpha v^n$ becomes\n\n$$\n\\begin{eqnarray}\nW=\\int dx~f=\\alpha v^n L.\n\\end{eqnarray}\n$$\n\nFor $n=0$ the work is\nindependent of speed, but for the wind resistance, where $n=2$,\nslowing down is essential if one wishes to reduce fuel consumption. It\nis also important to consider that engines are designed to be most\nefficient at a chosen range of power output. Thus, some cars will get\nbetter mileage at higher speeds (They perform better at 50 mph than at\n5 mph) despite the considerations mentioned above.\n\n## Going Ballistic, Projectile Motion or a Softer Approach, Falling Raindrops\n\n\nAs an example of Newton's Laws we consider projectile motion (or a\nfalling raindrop or a ball we throw up in the air) with a drag force. Even though air resistance is\nlargely proportional to the square of the velocity, we will consider\nthe drag force to be linear to the velocity, $\\boldsymbol{F}=-m\\gamma\\boldsymbol{v}$,\nfor the purposes of this exercise. The acceleration for a projectile moving upwards,\n$\\boldsymbol{a}=\\boldsymbol{F}/m$, becomes\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{dt}=-\\gamma v_x,\\\\\n\\nonumber\n\\frac{dv_y}{dt}=-\\gamma v_y-g,\n\\end{eqnarray}\n$$\n\nand $\\gamma$ has dimensions of inverse time. \n\nIf you on the other hand have a falling raindrop, how do these equations change? See for example Figure 2.1 in Taylor.\nLet us stay with a ball which is thrown up in the air at $t=0$. \n\n## Ways of solving these equations\n\nWe will go over two different ways to solve this equation. The first\nby direct integration, and the second as a differential equation. To\ndo this by direct integration, one simply multiplies both sides of the\nequations above by $dt$, then divide by the appropriate factors so\nthat the $v$s are all on one side of the equation and the $dt$ is on\nthe other. For the $x$ motion one finds an easily integrable equation,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{v_x}&=&-\\gamma dt,\\\\\n\\nonumber\n\\int_{v_{0x}}^{v_{x}}\\frac{dv_x}{v_x}&=&-\\gamma\\int_0^{t}dt,\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{x}}{v_{0x}}\\right)&=&-\\gamma t,\\\\\n\\nonumber\nv_{x}(t)&=&v_{0x}e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nThis is very much the result you would have written down\nby inspection. For the $y$-component of the velocity,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_y}{v_y+g/\\gamma}&=&-\\gamma dt\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{y}+g/\\gamma}{v_{0y}-g/\\gamma}\\right)&=&-\\gamma t_f,\\\\\n\\nonumber\nv_{fy}&=&-\\frac{g}{\\gamma}+\\left(v_{0y}+\\frac{g}{\\gamma}\\right)e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nWhereas $v_x$ starts at some value and decays\nexponentially to zero, $v_y$ decays exponentially to the terminal\nvelocity, $v_t=-g/\\gamma$.\n\n## Solving as differential equations\n\nAlthough this direct integration is simpler than the method we invoke\nbelow, the method below will come in useful for some slightly more\ndifficult differential equations in the future. The differential\nequation for $v_x$ is straight-forward to solve. Because it is first\norder there is one arbitrary constant, $A$, and by inspection the\nsolution is\n\n\n
\n\n$$\n\\begin{equation}\nv_x=Ae^{-\\gamma t}.\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\nThe arbitrary constants for equations of motion are usually determined\nby the initial conditions, or more generally boundary conditions. By\ninspection $A=v_{0x}$, the initial $x$ component of the velocity.\n\n\n## Differential Equations, contn\nThe differential equation for $v_y$ is a bit more complicated due to\nthe presence of $g$. Differential equations where all the terms are\nlinearly proportional to a function, in this case $v_y$, or to\nderivatives of the function, e.g., $v_y$, $dv_y/dt$,\n$d^2v_y/dt^2\\cdots$, are called linear differential equations. If\nthere are terms proportional to $v^2$, as would happen if the drag\nforce were proportional to the square of the velocity, the\ndifferential equation is not longer linear. Because this expression\nhas only one derivative in $v$ it is a first-order linear differential\nequation. If a term were added proportional to $d^2v/dt^2$ it would be\na second-order differential equation. In this case we have a term\ncompletely independent of $v$, the gravitational acceleration $g$, and\nthe usual strategy is to first rewrite the equation with all the\nlinear terms on one side of the equal sign,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_y}{dt}+\\gamma v_y=-g.\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\n## Splitting into two parts\n\nNow, the solution to the equation can be broken into two\nparts. Because this is a first-order differential equation we know\nthat there will be one arbitrary constant. Physically, the arbitrary\nconstant will be determined by setting the initial velocity, though it\ncould be determined by setting the velocity at any given time. Like\nmost differential equations, solutions are not \"solved\". Instead,\none guesses at a form, then shows the guess is correct. For these\ntypes of equations, one first tries to find a single solution,\ni.e. one with no arbitrary constants. This is called the {\\it\nparticular} solution, $y_p(t)$, though it should really be called\n\"a\" particular solution because there are an infinite number of such\nsolutions. One then finds a solution to the {\\it homogenous} equation,\nwhich is the equation with zero on the right-hand side,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,h}}{dt}+\\gamma v_{y,h}=0.\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nHomogenous solutions will have arbitrary constants. \n\nThe particular solution will solve the same equation as the original\ngeneral equation\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,p}}{dt}+\\gamma v_{y,p}=-g.\n\\label{_auto8} \\tag{8}\n\\end{equation}\n$$\n\nHowever, we don't need find one with arbitrary constants. Hence, it is\ncalled a **particular** solution.\n\nThe sum of the two,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=v_{y,p}+v_{y,h},\n\\label{_auto9} \\tag{9}\n\\end{equation}\n$$\n\nis a solution of the total equation because of the linear nature of\nthe differential equation. One has now found a *general* solution\nencompassing all solutions, because it both satisfies the general\nequation (like the particular solution), and has an arbitrary constant\nthat can be adjusted to fit any initial condition (like the homogneous\nsolution). If the equation were not linear, e.g if there were a term\nsuch as $v_y^2$ or $v_y\\dot{v}_y$, this technique would not work.\n\n## More details\n\nReturning to the example above, the homogenous solution is the same as\nthat for $v_x$, because there was no gravitational acceleration in\nthat case,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,h}=Be^{-\\gamma t}.\n\\label{_auto10} \\tag{10}\n\\end{equation}\n$$\n\nIn this case a particular solution is one with constant velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,p}=-g/\\gamma.\n\\label{_auto11} \\tag{11}\n\\end{equation}\n$$\n\nNote that this is the terminal velocity of a particle falling from a\ngreat height. The general solution is thus,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=Be^{-\\gamma t}-g/\\gamma,\n\\label{_auto12} \\tag{12}\n\\end{equation}\n$$\n\nand one can find $B$ from the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{0y}=B-g/\\gamma,~~~B=v_{0y}+g/\\gamma.\n\\label{_auto13} \\tag{13}\n\\end{equation}\n$$\n\nPlugging in the expression for $B$ gives the $y$ motion given the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=(v_{0y}+g/\\gamma)e^{-\\gamma t}-g/\\gamma.\n\\label{_auto14} \\tag{14}\n\\end{equation}\n$$\n\nIt is easy to see that this solution has $v_y=v_{0y}$ when $t=0$ and\n$v_y=-g/\\gamma$ when $t\\rightarrow\\infty$.\n\nOne can also integrate the two equations to find the coordinates $x$\nand $y$ as functions of $t$,\n\n$$\n\\begin{eqnarray}\nx&=&\\int_0^t dt'~v_{0x}(t')=\\frac{v_{0x}}{\\gamma}\\left(1-e^{-\\gamma t}\\right),\\\\\n\\nonumber\ny&=&\\int_0^t dt'~v_{0y}(t')=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\end{eqnarray}\n$$\n\nIf the question was to find the position at a time $t$, we would be\nfinished. However, the more common goal in a projectile equation\nproblem is to find the range, i.e. the distance $x$ at which $y$\nreturns to zero. For the case without a drag force this was much\nsimpler. The solution for the $y$ coordinate would have been\n$y=v_{0y}t-gt^2/2$. One would solve for $t$ to make $y=0$, which would\nbe $t=2v_{0y}/g$, then plug that value for $t$ into $x=v_{0x}t$ to\nfind $x=2v_{0x}v_{0y}/g=v_0\\sin(2\\theta_0)/g$. One follows the same\nsteps here, except that the expression for $y(t)$ is more\ncomplicated. Searching for the time where $y=0$, and we get\n\n\n
\n\n$$\n\\begin{equation}\n0=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\label{_auto15} \\tag{15}\n\\end{equation}\n$$\n\nThis cannot be inverted into a simple expression $t=\\cdots$. Such\nexpressions are known as \"transcendental equations\", and are not the\nrare instance, but are the norm. In the days before computers, one\nmight plot the right-hand side of the above graphically as\na function of time, then find the point where it crosses zero.\n\nNow, the most common way to solve for an equation of the above type\nwould be to apply Newton's method numerically. This involves the\nfollowing algorithm for finding solutions of some equation $F(t)=0$.\n\n1. First guess a value for the time, $t_{\\rm guess}$.\n\n2. Calculate $F$ and its derivative, $F(t_{\\rm guess})$ and $F'(t_{\\rm guess})$. \n\n3. Unless you guessed perfectly, $F\\ne 0$, and assuming that $\\Delta F\\approx F'\\Delta t$, one would choose \n\n4. $\\Delta t=-F(t_{\\rm guess})/F'(t_{\\rm guess})$.\n\n5. Now repeat step 1, but with $t_{\\rm guess}\\rightarrow t_{\\rm guess}+\\Delta t$.\n\nIf the $F(t)$ were perfectly linear in $t$, one would find $t$ in one\nstep. Instead, one typically finds a value of $t$ that is closer to\nthe final answer than $t_{\\rm guess}$. One breaks the loop once one\nfinds $F$ within some acceptable tolerance of zero. A program to do\nthis will be added shortly.\n\n## Motion in a Magnetic Field\n\n\nAnother example of a velocity-dependent force is magnetism,\n\n$$\n\\begin{eqnarray}\n\\boldsymbol{F}&=&q\\boldsymbol{v}\\times\\boldsymbol{B},\\\\\n\\nonumber\nF_i&=&q\\sum_{jk}\\epsilon_{ijk}v_jB_k.\n\\end{eqnarray}\n$$\n\nFor a uniform field in the $z$ direction $\\boldsymbol{B}=B\\hat{z}$, the force can only have $x$ and $y$ components,\n\n$$\n\\begin{eqnarray}\nF_x&=&qBv_y\\\\\n\\nonumber\nF_y&=&-qBv_x.\n\\end{eqnarray}\n$$\n\nThe differential equations are\n\n$$\n\\begin{eqnarray}\n\\dot{v}_x&=&\\omega_c v_y,\\omega_c= qB/m\\\\\n\\nonumber\n\\dot{v}_y&=&-\\omega_c v_x.\n\\end{eqnarray}\n$$\n\nOne can solve the equations by taking time derivatives of either equation, then substituting into the other equation,\n\n$$\n\\begin{eqnarray}\n\\ddot{v}_x=\\omega_c\\dot{v_y}=-\\omega_c^2v_x,\\\\\n\\nonumber\n\\ddot{v}_y&=&-\\omega_c\\dot{v}_x=-\\omega_cv_y.\n\\end{eqnarray}\n$$\n\nThe solution to these equations can be seen by inspection,\n\n$$\n\\begin{eqnarray}\nv_x&=&A\\sin(\\omega_ct+\\phi),\\\\\n\\nonumber\nv_y&=&A\\cos(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nOne can integrate the equations to find the positions as a function of time,\n\n$$\n\\begin{eqnarray}\nx-x_0&=&\\int_{x_0}^x dx=\\int_0^t dt v(t)\\\\\n\\nonumber\n&=&\\frac{-A}{\\omega_c}\\cos(\\omega_ct+\\phi),\\\\\n\\nonumber\ny-y_0&=&\\frac{A}{\\omega_c}\\sin(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nThe trajectory is a circle centered at $x_0,y_0$ with amplitude $A$ rotating in the clockwise direction.\n\nThe equations of motion for the $z$ motion are\n\n\n
\n\n$$\n\\begin{equation}\n\\dot{v_z}=0,\n\\label{_auto16} \\tag{16}\n\\end{equation}\n$$\n\nwhich leads to\n\n\n
\n\n$$\n\\begin{equation}\nz-z_0=V_zt.\n\\label{_auto17} \\tag{17}\n\\end{equation}\n$$\n\nAdded onto the circle, the motion is helical.\n\nNote that the kinetic energy,\n\n\n
\n\n$$\n\\begin{equation}\nT=\\frac{1}{2}m(v_x^2+v_y^2+v_z^2)=\\frac{1}{2}m(\\omega_c^2A^2+V_z^2),\n\\label{_auto18} \\tag{18}\n\\end{equation}\n$$\n\nis constant. This is because the force is perpendicular to the\nvelocity, so that in any differential time element $dt$ the work done\non the particle $\\boldsymbol{F}\\cdot{dr}=dt\\boldsymbol{F}\\cdot{v}=0$.\n\nOne should think about the implications of a velocity dependent\nforce. Suppose one had a constant magnetic field in deep space. If a\nparticle came through with velocity $v_0$, it would undergo cyclotron\nmotion with radius $R=v_0/\\omega_c$. However, if it were still its\nmotion would remain fixed. Now, suppose an observer looked at the\nparticle in one reference frame where the particle was moving, then\nchanged their velocity so that the particle's velocity appeared to be\nzero. The motion would change from circular to fixed. Is this\npossible?\n\nThe solution to the puzzle above relies on understanding\nrelativity. Imagine that the first observer believes $\\boldsymbol{B}\\ne 0$ and\nthat the electric field $\\boldsymbol{E}=0$. If the observer then changes\nreference frames by accelerating to a velocity $\\boldsymbol{v}$, in the new\nframe $\\boldsymbol{B}$ and $\\boldsymbol{E}$ both change. If the observer moved to the\nframe where the charge, originally moving with a small velocity $v$,\nis now at rest, the new electric field is indeed $\\boldsymbol{v}\\times\\boldsymbol{B}$,\nwhich then leads to the same acceleration as one had before. If the\nvelocity is not small compared to the speed of light, additional\n$\\gamma$ factors come into play,\n$\\gamma=1/\\sqrt{1-(v/c)^2}$. Relativistic motion will not be\nconsidered in this course.\n\n\n\n## Sliding Block tied to a Wall\n\nAnother classical case is that of simple harmonic oscillations, here represented by a block sliding on a horizontal frictionless surface. The block is tied to a wall with a spring. If the spring is not compressed or stretched too far, the force on the block at a given position $x$ is\n\n$$\nF=-kx.\n$$\n\nThe negative sign means that the force acts to restore the object to an equilibrium position. Newton's equation of motion for this idealized system is then\n\n$$\nm\\frac{d^2x}{dt^2}=-kx,\n$$\n\nor we could rephrase it as\n\n\n
\n\n$$\n\\frac{d^2x}{dt^2}=-\\frac{k}{m}x=-\\omega_0^2x,\n\\label{eq:newton1} \\tag{19}\n$$\n\nwith the angular frequency $\\omega_0^2=k/m$. \n\nThe above differential equation has the advantage that it can be solved analytically with solutions on the form\n\n$$\nx(t)=Acos(\\omega_0t+\\nu),\n$$\n\nwhere $A$ is the amplitude and $\\nu$ the phase constant. This provides in turn an important test for the numerical\nsolution and the development of a program for more complicated cases which cannot be solved analytically. \n\n\n\n## Simple Example, Block tied to a Wall\n\nWith the position $x(t)$ and the velocity $v(t)=dx/dt$ we can reformulate Newton's equation in the following way\n\n$$\n\\frac{dx(t)}{dt}=v(t),\n$$\n\nand\n\n$$\n\\frac{dv(t)}{dt}=-\\omega_0^2x(t).\n$$\n\nWe are now going to solve these equations using first the standard forward Euler method. Later we will try to improve upon this.\n\n\n## Simple Example, Block tied to a Wall\n\nBefore proceeding however, it is important to note that in addition to the exact solution, we have at least two further tests which can be used to check our solution. \n\nSince functions like $cos$ are periodic with a period $2\\pi$, then the solution $x(t)$ has also to be periodic. This means that\n\n$$\nx(t+T)=x(t),\n$$\n\nwith $T$ the period defined as\n\n$$\nT=\\frac{2\\pi}{\\omega_0}=\\frac{2\\pi}{\\sqrt{k/m}}.\n$$\n\nObserve that $T$ depends only on $k/m$ and not on the amplitude of the solution. \n\n\n## Simple Example, Block tied to a Wall\n\nIn addition to the periodicity test, the total energy has also to be conserved. \n\nSuppose we choose the initial conditions\n\n$$\nx(t=0)=1\\hspace{0.1cm} \\mathrm{m}\\hspace{1cm} v(t=0)=0\\hspace{0.1cm}\\mathrm{m/s},\n$$\n\nmeaning that block is at rest at $t=0$ but with a potential energy\n\n$$\nE_0=\\frac{1}{2}kx(t=0)^2=\\frac{1}{2}k.\n$$\n\nThe total energy at any time $t$ has however to be conserved, meaning that our solution has to fulfil the condition\n\n$$\nE_0=\\frac{1}{2}kx(t)^2+\\frac{1}{2}mv(t)^2.\n$$\n\nWe will derive this equation in our discussion on [energy conservation](https://mhjensen.github.io/Physics321/doc/pub/energyconserv/html/energyconserv.html).\n\n## Simple Example, Block tied to a Wall\n\nAn algorithm which implements these equations is included below.\n * Choose the initial position and speed, with the most common choice $v(t=0)=0$ and some fixed value for the position. \n\n * Choose the method you wish to employ in solving the problem.\n\n * Subdivide the time interval $[t_i,t_f] $ into a grid with step size\n\n$$\nh=\\frac{t_f-t_i}{N},\n$$\n\nwhere $N$ is the number of mesh points. \n * Calculate now the total energy given by\n\n$$\nE_0=\\frac{1}{2}kx(t=0)^2=\\frac{1}{2}k.\n$$\n\n* Choose ODE solver to obtain $x_{i+1}$ and $v_{i+1}$ starting from the previous values $x_i$ and $v_i$.\n\n * When we have computed $x(v)_{i+1}$ we upgrade $t_{i+1}=t_i+h$.\n\n * This iterative process continues till we reach the maximum time $t_f$.\n\n * The results are checked against the exact solution. Furthermore, one has to check the stability of the numerical solution against the chosen number of mesh points $N$. \n\n## Simple Example, Block tied to a Wall, python code\n\nThe following python program ( code will be added shortly)\n\n\n```python\n#\n# This program solves Newtons equation for a block sliding on\n# an horizontal frictionless surface.\n# The block is tied to the wall with a spring, so N's eq takes the form:\n#\n# m d^2x/dt^2 = - kx\n#\n# In order to make the solution dimless, we set k/m = 1.\n# This results in two coupled diff. eq's that may be written as:\n#\n# dx/dt = v\n# dv/dt = -x\n#\n# The user has to specify the initial velocity and position,\n# and the number of steps. The time interval is fixed to\n# t \\in [0, 4\\pi) (two periods)\n#\n```\n", "meta": {"hexsha": "0f5f34813d77ef081785854eb0dc344aff9c1bbd", "size": 78369, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/week4/ipynb/.ipynb_checkpoints/week4-checkpoint.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2020-01-09T17:41:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T00:48:58.000Z", "max_issues_repo_path": "doc/pub/week4/ipynb/.ipynb_checkpoints/week4-checkpoint.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-08T03:47:53.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-15T15:02:57.000Z", "max_forks_repo_path": "doc/pub/week4/ipynb/.ipynb_checkpoints/week4-checkpoint.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2020-01-10T20:40:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T20:28:41.000Z", "avg_line_length": 29.395723931, "max_line_length": 290, "alphanum_fraction": 0.5649810512, "converted": true, "num_tokens": 13929, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.3593641451601019, "lm_q2_score": 0.41489884579676883, "lm_q1q2_score": 0.14909976904766878}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n Multiprocess sampling (4 chains in 4 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n Sampling 4 chains: 100%|██████████| 60000/60000 [00:08<00:00, 7111.54draws/s] \n The number of effective samples is smaller than 25% for some parameters.\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n### Appendix 1.6.2 Extending to Two Switchpoints\n\nReaders might be interested in how the previous model can be extended to more than a single switchpoint, or may question the assumption of only one switchpoint. We'll start with extending the model to consider two switchpoints (which implies 3 $\\lambda_i$ parameters). The model looks vert similar to the previous:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau_1 \\cr\n\\lambda_2 & \\text{if } \\tau_1 \\le t \\lt \\tau_2 \\cr\n\\lambda_3 & \\text{if } t \\ge \\tau_2\n\\end{cases}\n$$\n\nwhere\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_3 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\nand\n\n\\begin{align}\n& \\tau_1 \\sim \\text{DiscreteUniform(1,69) } \\\\\\\n& \\tau_2 \\sim \\text{DiscreteUniform}(\\tau_1,70) \\\\\\\n\\end{align}\n\nLet's code this model up, which looks very similar to our previous code:\n\n\n```python\nwith pm.Model() as model:\n \n alpha = 1/count_data.mean()\n \n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n lambda_3 = pm.Exponential(\"lambda_3\", alpha)\n \n tau_1 = pm.DiscreteUniform(\"tau_1\", lower=0, upper=n_count_data-1)\n tau_2 = pm.DiscreteUniform(\"tau_2\", lower=tau_1, upper=n_count_data)\n \nwith model:\n \n idx = np.arange(n_count_data)\n lambda_ = pm.math.switch(idx < tau_2,\n pm.math.switch(idx < tau_1,\n lambda_1,\n lambda_2),\n lambda_3)\n observation = pm.Poisson('obs', lambda_, observed=count_data)\n \n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000, step=step)\n```\n\n Multiprocess sampling (4 chains in 4 jobs)\n CompoundStep\n >Metropolis: [tau_2]\n >Metropolis: [tau_1]\n >Metropolis: [lambda_3]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n Sampling 4 chains: 100%|██████████| 60000/60000 [00:08<00:00, 7225.63draws/s]\n The number of effective samples is smaller than 10% for some parameters.\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\nlambda_3_samples = trace['lambda_3']\ntau_1_samples = trace['tau_1']\ntau_2_samples = trace['tau_2']\n```\n\n\n```python\nplt.rcParams['figure.figsize'] = (12.5, 10)\n\n# lambda_1\nax = plt.subplot(511)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples,\n histtype='stepfilled',\n bins=100,\n alpha=0.85,\n label=r\"Posterior of $\\lambda_1$\",\n color='#A60628',\n density=True)\nplt.legend(loc='upper left')\nplt.ylabel('Density')\nplt.xlabel(r\"$\\lambda_1$ value\")\nplt.title(r\"Posterior Distribution of the variables $\\lambda_1, \\lambda_2, \\lambda_3, \\tau_1 ~&~ \\tau_2$\")\nplt.xlim([15, 30])\n\n# lambda_2\nax = plt.subplot(512)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_2_samples,\n histtype='stepfilled',\n bins=100,\n alpha=0.85,\n label=r\"Posterior of $\\lambda_2$\",\n color='#7A68A6',\n density=True)\nplt.legend(loc='upper left')\nplt.ylabel('Density')\nplt.xlim([30, 90])\nplt.xlabel(r\"$\\lambda_2$ value\")\n\n# lambda_3\nax = plt.subplot(513)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_3_samples,\n histtype='stepfilled',\n bins=100,\n alpha=0.85,\n label=r\"Posterior of $\\lambda_3$\",\n color='#3A68A6',\n density=True)\nplt.legend(loc='upper left')\nplt.ylabel('Density')\nplt.xlim([15, 30])\nplt.xlabel(r\"$\\lambda_3$ value\")\n\n# tau_1\nplt.subplot(514)\nw = 1.0 / tau_1_samples.shape[0] * np.ones_like(tau_1_samples)\nplt.hist(tau_1_samples,\n bins=n_count_data,\n alpha=1,\n label=r'Posterior of $\\tau_1$',\n color='#467821',\n weights=w,\n rwidth=2)\nplt.xticks(np.arange(n_count_data))\nplt.legend(loc='upper left')\nplt.ylim([0, 0.75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r'$\\tau_1$ (in days)')\nplt.ylabel('Probability')\n\n# tau_2\nplt.subplot(515)\nw = 1.0 / tau_2_samples.shape[0] * np.ones_like(tau_2_samples)\nplt.hist(tau_2_samples,\n bins=n_count_data,\n alpha=1,\n label=r'Posterior of $\\tau_2$',\n color='#767821',\n weights=w,\n rwidth=2)\nplt.xticks(np.arange(n_count_data))\nplt.legend(loc='upper left')\nplt.ylim([0, 0.75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r'$\\tau_2$ (in days)')\nplt.ylabel('Probability')\n```\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\nprint(lambda_1_samples.mean())\nprint(lambda_2_samples.mean())\n```\n\n 17.758062445442253\n 58.36165697369309\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n# 2\npct_inc_post = (lambda_2_samples - lambda_1_samples)/lambda_2_samples\n\n# frequentist \"estimate/answer\"\nfreq_est = pct_inc_post.mean()\n\n# posterior of expected percentage increase\nfig, ax = plt.subplots(figsize=(12, 9))\n\nax.hist(pct_inc_post,\n bins=100,\n color='#348ABD',\n density=True,\n label='Bayesian Posterior')\nplt.axvline(freq_est,\n color=\"#A60628\",\n label='Frequentist Estimate')\nplt.title(\"Posterior Distribution of the Expected Percentage Increase\")\nplt.xlabel('Percentage Increase')\nplt.ylabel('Density')\nplt.legend(loc='upper left')\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n# knowing that we are \"before\" the switchpoint, we are in the realm\n# of the first lambda (lambda_1), so the expected message rate is the mean\n# of that distribution:\nprint(lambda_1_samples[:45].mean()) \n```\n\n 17.882761522264225\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "4d8ead0e067415682b330ee863036b930ee093f2", "size": 368860, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "marshallm94/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "36b453db56691cff2307a83becfaa9e838cdb401", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "marshallm94/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "36b453db56691cff2307a83becfaa9e838cdb401", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "marshallm94/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "36b453db56691cff2307a83becfaa9e838cdb401", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 264.2263610315, "max_line_length": 89600, "alphanum_fraction": 0.9011874424, "converted": true, "num_tokens": 13004, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295350395727, "lm_q2_score": 0.33458943461801643, "lm_q1q2_score": 0.14906947523451838}}
{"text": "\n# Infinite matter, from the electron gas to nuclear matter\n\n \n**[Morten Hjorth-Jensen](http://computationalphysics.no), National Superconducting Cyclotron Laboratory and Department of Physics and Astronomy, Michigan State University, East Lansing, MI 48824, USA & Department of Physics, University of Oslo, Oslo, Norway**\n\nDate: **July 2015**\n\n## Introduction to studies of infinite matter\n\n\nStudies of infinite nuclear matter play an important role in nuclear physics. The aim of this part of the lectures is to provide the necessary ingredients for perfoming studies of neutron star matter (or matter in $\\beta$-equilibrium) and symmetric nuclear matter. We start however with the electron gas in two and three dimensions for both historical and pedagogical reasons. Since there are several benchmark calculations for the electron gas, this small detour will allow us to establish the necessary formalism. Thereafter we will study infinite nuclear matter \n* at the Hartree-Fock with realistic nuclear forces and\n\n* using many-body methods like coupled-cluster theory or in-medium SRG as discussed in our previous sections.\n\n## The infinite electron gas\n\nThe electron gas is perhaps the only realistic model of a \nsystem of many interacting particles that allows for a solution\nof the Hartree-Fock equations on a closed form. Furthermore, to first order in the interaction, one can also\ncompute on a closed form the total energy and several other properties of a many-particle systems. \nThe model gives a very good approximation to the properties of valence electrons in metals.\nThe assumptions are\n\n * System of electrons that is not influenced by external forces except by an attraction provided by a uniform background of ions. These ions give rise to a uniform background charge. The ions are stationary.\n\n * The system as a whole is neutral.\n\n * We assume we have $N_e$ electrons in a cubic box of length $L$ and volume $\\Omega=L^3$. This volume contains also a uniform distribution of positive charge with density $N_ee/\\Omega$. \n\nThe homogeneous electron gas is one of the few examples of a system of many\ninteracting particles that allows for a solution of the mean-field\nHartree-Fock equations on a closed form. To first order in the\nelectron-electron interaction, this applies to ground state properties\nlike the energy and its pertinent equation of state as well. The\nhomogeneus electron gas is a system of electrons that is not\ninfluenced by external forces except by an attraction provided by a\nuniform background of ions. These ions give rise to a uniform\nbackground charge. The ions are stationary and the system as a whole\nis neutral.\nIrrespective of this simplicity, this system, in both two and\nthree-dimensions, has eluded a proper description of correlations in\nterms of various first principle methods, except perhaps for quantum\nMonte Carlo methods. In particular, the diffusion Monte Carlo\ncalculations of [Ceperley](http://journals.aps.org/prl/abstract/10.1103/PhysRevLett.45.566) \nand [Ceperley and Tanatar](http://journals.aps.org/prb/abstract/10.1103/PhysRevB.39.5005) \nare presently still considered as the\nbest possible benchmarks for the two- and three-dimensional electron\ngas. \n\n\n\nThe electron gas, in \ntwo or three dimensions is thus interesting as a test-bed for \nelectron-electron correlations. The three-dimensional \nelectron gas is particularly important as a cornerstone \nof the local-density approximation in density-functional \ntheory. In the physical world, systems \nsimilar to the three-dimensional electron gas can be \nfound in, for example, alkali metals and doped \nsemiconductors. Two-dimensional electron fluids are \nobserved on metal and liquid-helium surfaces, as well as \nat metal-oxide-semiconductor interfaces. However, the Coulomb \ninteraction has an infinite range, and therefore \nlong-range correlations play an essential role in the\nelectron gas. \n\n\n\n\nAt low densities, the electrons become \nlocalized and form a lattice. This so-called Wigner \ncrystallization is a direct consequence \nof the long-ranged repulsive interaction. At higher\ndensities, the electron gas is better described as a\nliquid.\nWhen using, for example, Monte Carlo methods the electron gas must be approximated \nby a finite system. The long-range Coulomb interaction \nin the electron gas causes additional finite-size effects that are not\npresent in other infinite systems like nuclear matter or neutron star matter.\nThis poses additional challenges to many-body methods when applied \nto the electron gas.\n\n\n\n\n\n## The infinite electron gas as a homogenous system\n\nThis is a homogeneous system and the one-particle wave functions are given by plane wave functions normalized to a volume $\\Omega$ \nfor a box with length $L$ (the limit $L\\rightarrow \\infty$ is to be taken after we have computed various expectation values)\n\n$$\n\\psi_{\\mathbf{k}\\sigma}(\\mathbf{r})= \\frac{1}{\\sqrt{\\Omega}}\\exp{(i\\mathbf{kr})}\\xi_{\\sigma}\n$$\n\nwhere $\\mathbf{k}$ is the wave number and $\\xi_{\\sigma}$ is a spin function for either spin up or down\n\n$$\n\\xi_{\\sigma=+1/2}=\\left(\\begin{array}{c} 1 \\\\ 0 \\end{array}\\right) \\hspace{0.5cm}\n\\xi_{\\sigma=-1/2}=\\left(\\begin{array}{c} 0 \\\\ 1 \\end{array}\\right).\n$$\n\n## Periodic boundary conditions\n\n\nWe assume that we have periodic boundary conditions which limit the allowed wave numbers to\n\n$$\nk_i=\\frac{2\\pi n_i}{L}\\hspace{0.5cm} i=x,y,z \\hspace{0.5cm} n_i=0,\\pm 1,\\pm 2, \\dots\n$$\n\nWe assume first that the electrons interact via a central, symmetric and translationally invariant\ninteraction $V(r_{12})$ with\n$r_{12}=|\\mathbf{r}_1-\\mathbf{r}_2|$. The interaction is spin independent.\n\nThe total Hamiltonian consists then of kinetic and potential energy\n\n$$\n\\hat{H} = \\hat{T}+\\hat{V}.\n$$\n\nThe operator for the kinetic energy can be written as\n\n$$\n\\hat{T}=\\sum_{\\mathbf{k}\\sigma}\\frac{\\hbar^2k^2}{2m}a_{\\mathbf{k}\\sigma}^{\\dagger}a_{\\mathbf{k}\\sigma}.\n$$\n\n## Defining the Hamiltonian operator\n\nThe Hamiltonian operator is given by\n\n$$\n\\hat{H}=\\hat{H}_{el}+\\hat{H}_{b}+\\hat{H}_{el-b},\n$$\n\nwith the electronic part\n\n$$\n\\hat{H}_{el}=\\sum_{i=1}^N\\frac{p_i^2}{2m}+\\frac{e^2}{2}\\sum_{i\\ne j}\\frac{e^{-\\mu |\\mathbf{r}_i-\\mathbf{r}_j|}}{|\\mathbf{r}_i-\\mathbf{r}_j|},\n$$\n\nwhere we have introduced an explicit convergence factor\n(the limit $\\mu\\rightarrow 0$ is performed after having calculated the various integrals).\nCorrespondingly, we have\n\n$$\n\\hat{H}_{b}=\\frac{e^2}{2}\\int\\int d\\mathbf{r}d\\mathbf{r}'\\frac{n(\\mathbf{r})n(\\mathbf{r}')e^{-\\mu |\\mathbf{r}-\\mathbf{r}'|}}{|\\mathbf{r}-\\mathbf{r}'|},\n$$\n\nwhich is the energy contribution from the positive background charge with density\n$n(\\mathbf{r})=N/\\Omega$. Finally,\n\n$$\n\\hat{H}_{el-b}=-\\frac{e^2}{2}\\sum_{i=1}^N\\int d\\mathbf{r}\\frac{n(\\mathbf{r})e^{-\\mu |\\mathbf{r}-\\mathbf{x}_i|}}{|\\mathbf{r}-\\mathbf{x}_i|},\n$$\n\nis the interaction between the electrons and the positive background.\n\n\n\n## Single-particle Hartree-Fock energy\n\nIn the first exercise below we show that the Hartree-Fock energy can be written as\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m_e}-\\frac{e^{2}}\n{\\Omega^{2}}\\sum_{k'\\leq\nk_{F}}\\int d\\mathbf{r}e^{i(\\mathbf{k}'-\\mathbf{k})\\mathbf{r}}\\int\nd\\mathbf{r'}\\frac{e^{i(\\mathbf{k}-\\mathbf{k}')\\mathbf{r}'}}\n{\\vert\\mathbf{r}-\\mathbf{r}'\\vert}\n$$\n\nresulting in\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m_e}-\\frac{e^{2}\nk_{F}}{2\\pi}\n\\left[\n2+\\frac{k_{F}^{2}-k^{2}}{kk_{F}}ln\\left\\vert\\frac{k+k_{F}}\n{k-k_{F}}\\right\\vert\n\\right]\n$$\n\nThe previous result can be rewritten in terms of the density\n\n$$\nn= \\frac{k_F^3}{3\\pi^2}=\\frac{3}{4\\pi r_s^3},\n$$\n\nwhere $n=N_e/\\Omega$, $N_e$ being the number of electrons, and $r_s$ is the radius of a sphere which represents the volum per conducting electron. \nIt can be convenient to use the Bohr radius $a_0=\\hbar^2/e^2m_e$.\nFor most metals we have a relation $r_s/a_0\\sim 2-6$. The quantity $r_s$ is dimensionless.\n\n\nIn the second exercise below we find that\nthe total energy\n$E_0/N_e=\\langle\\Phi_{0}|\\hat{H}|\\Phi_{0}\\rangle/N_e$ for\nfor this system to first order in the interaction is given as\n\n$$\nE_0/N_e=\\frac{e^2}{2a_0}\\left[\\frac{2.21}{r_s^2}-\\frac{0.916}{r_s}\\right].\n$$\n\n\n\n## Exercise 1: Hartree-Fock single-particle solution for the electron gas\n\nThe electron gas model allows closed form solutions for quantities like the \nsingle-particle Hartree-Fock energy. The latter quantity is given by the following expression\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m}-\\frac{e^{2}}\n{V^{2}}\\sum_{k'\\leq\nk_{F}}\\int d\\mathbf{r}e^{i(\\mathbf{k'}-\\mathbf{k})\\mathbf{r}}\\int\nd\\mathbf{r}'\\frac{e^{i(\\mathbf{k}-\\mathbf{k'})\\mathbf{r}'}}\n{\\vert\\mathbf{r}-\\mathbf{r'}\\vert}\n$$\n\n**a)**\nShow first that\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m}-\\frac{e^{2}\nk_{F}}{2\\pi}\n\\left[\n2+\\frac{k_{F}^{2}-k^{2}}{kk_{F}}ln\\left\\vert\\frac{k+k_{F}}\n{k-k_{F}}\\right\\vert\n\\right]\n$$\n\n\n\n**Hint.**\nHint: Introduce the convergence factor \n$e^{-\\mu\\vert\\mathbf{r}-\\mathbf{r}'\\vert}$\nin the potential and use $\\sum_{\\mathbf{k}}\\rightarrow\n\\frac{V}{(2\\pi)^{3}}\\int d\\mathbf{k}$\n\n\n\n\n\n**Solution.**\nWe want to show that, given the Hartree-Fock equation for the electron gas\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m}-\\frac{e^{2}}\n{V^{2}}\\sum_{p\\leq\nk_{F}}\\int d\\mathbf{r}\\exp{(i(\\mathbf{p}-\\mathbf{k})\\mathbf{r})}\\int\nd\\mathbf{r}'\\frac{\\exp{(i(\\mathbf{k}-\\mathbf{p})\\mathbf{r}'})}\n{\\vert\\mathbf{r}-\\mathbf{r'}\\vert}\n$$\n\nthe single-particle energy can be written as\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m}-\\frac{e^{2}\nk_{F}}{2\\pi}\n\\left[\n2+\\frac{k_{F}^{2}-k^{2}}{kk_{F}}ln\\left\\vert\\frac{k+k_{F}}\n{k-k_{F}}\\right\\vert\n\\right].\n$$\n\nWe introduce the convergence factor \n$e^{-\\mu\\vert\\mathbf{r}-\\mathbf{r}'\\vert}$\nin the potential and use $\\sum_{\\mathbf{k}}\\rightarrow\n\\frac{V}{(2\\pi)^{3}}\\int d\\mathbf{k}$. We can then rewrite the integral as\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{e^{2}}\n{V^{2}}\\sum_{k'\\leq\nk_{F}}\\int d\\mathbf{r}\\exp{(i(\\mathbf{k'}-\\mathbf{k})\\mathbf{r})}\\int\nd\\mathbf{r}'\\frac{\\exp{(i(\\mathbf{k}-\\mathbf{p})\\mathbf{r}'})}\n{\\vert\\mathbf{r}-\\mathbf{r'}\\vert}= \n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{e^{2}}{V (2\\pi)^3} \\int d\\mathbf{r}\\int\n\\frac{d\\mathbf{r}'}{\\vert\\mathbf{r}-\\mathbf{r'}\\vert}\\exp{(-i\\mathbf{k}(\\mathbf{r}-\\mathbf{r}'))}\\int d\\mathbf{p}\\exp{(i\\mathbf{p}(\\mathbf{r}-\\mathbf{r}'))},\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nand introducing the abovementioned convergence factor we have\n\n\n
\n\n$$\n\\begin{equation}\n\\lim_{\\mu \\to 0}\\frac{e^{2}}{V (2\\pi)^3} \\int d\\mathbf{r}\\int d\\mathbf{r}'\\frac{\\exp{(-\\mu\\vert\\mathbf{r}-\\mathbf{r}'\\vert})}{\\vert\\mathbf{r}-\\mathbf{r'}\\vert}\\int d\\mathbf{p}\\exp{(i(\\mathbf{p}-\\mathbf{k})(\\mathbf{r}-\\mathbf{r}'))}.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\nWith a change variables to $\\mathbf{x} = \\mathbf{r}-\\mathbf{r}'$ and $\\mathbf{y}=\\mathbf{r}'$ we rewrite the last integral as\n\n$$\n\\lim_{\\mu \\to 0}\\frac{e^{2}}{V (2\\pi)^3} \\int d\\mathbf{p}\\int d\\mathbf{y}\\int d\\mathbf{x}\\exp{(i(\\mathbf{p}-\\mathbf{k})\\mathbf{x})}\\frac{\\exp{(-\\mu\\vert\\mathbf{x}\\vert})}{\\vert\\mathbf{x}\\vert}.\n$$\n\nThe integration over $\\mathbf{x}$ can be performed using spherical coordinates, resulting in (with $x=\\vert \\mathbf{x}\\vert$)\n\n$$\n\\int d\\mathbf{x}\\exp{(i(\\mathbf{p}-\\mathbf{k})\\mathbf{x})}\\frac{\\exp{(-\\mu\\vert\\mathbf{x}\\vert})}{\\vert\\mathbf{x}\\vert}=\\int x^2 dx d\\phi d\\cos{(\\theta)}\\exp{(i(\\mathbf{p}-\\mathbf{k})x\\cos{(\\theta))}}\\frac{\\exp{(-\\mu x)}}{x}.\n$$\n\nWe obtain\n\n\n
\n\n$$\n\\begin{equation}\n4\\pi \\int dx \\frac{ \\sin{(\\vert \\mathbf{p}-\\mathbf{k}\\vert)x} }{\\vert \\mathbf{p}-\\mathbf{k}\\vert}{\\exp{(-\\mu x)}}= \\frac{4\\pi}{\\mu^2+\\vert \\mathbf{p}-\\mathbf{k}\\vert^2}.\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nThis results gives us\n\n\n
\n\n$$\n\\begin{equation}\n\\lim_{\\mu \\to 0}\\frac{e^{2}}{V (2\\pi)^3} \\int d\\mathbf{p}\\int d\\mathbf{y}\\frac{4\\pi}{\\mu^2+\\vert \\mathbf{p}-\\mathbf{k}\\vert^2}=\\lim_{\\mu \\to 0}\\frac{e^{2}}{ 2\\pi^2} \\int d\\mathbf{p}\\frac{1}{\\mu^2+\\vert \\mathbf{p}-\\mathbf{k}\\vert^2},\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\nwhere we have used that the integrand on the left-hand side does not depend on $\\mathbf{y}$ and that $\\int d\\mathbf{y}=V$.\n\nIntroducing spherical coordinates we can rewrite the integral as\n\n\n
\n\n$$\n\\begin{equation}\n\\lim_{\\mu \\to 0}\\frac{e^{2}}{ 2\\pi^2} \\int d\\mathbf{p}\\frac{1}{\\mu^2+\\vert \\mathbf{p}-\\mathbf{k}\\vert^2}=\\frac{e^{2}}{ 2\\pi^2} \\int d\\mathbf{p}\\frac{1}{\\vert \\mathbf{p}-\\mathbf{k}\\vert^2}= \n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{e^{2}}{\\pi} \\int_0^{k_F} p^2dp\\int_0^{\\pi} d\\theta\\cos{(\\theta)}\\frac{1}{p^2+k^2-2pk\\cos{(\\theta)}},\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nand with the change of variables $\\cos{(\\theta)}=u$ we have\n\n$$\n\\frac{e^{2}}{\\pi} \\int_0^{k_F} p^2dp\\int_{0}^{\\pi} d\\theta\\cos{(\\theta)}\\frac{1}{p^2+k^2-2pk\\cos{(\\theta)}}=\\frac{e^{2}}{\\pi} \\int_0^{k_F} p^2dp\\int_{-1}^{1} du\\frac{1}{p^2+k^2-2pku},\n$$\n\nwhich gives\n\n$$\n\\frac{e^{2}}{k\\pi} \\int_0^{k_F} pdp\\left\\{ln(\\vert p+k\\vert)-ln(\\vert p-k\\vert)\\right\\}.\n$$\n\nIntroducing new variables $x=p+k$ and $y=p-k$, we obtain after some straightforward reordering of the integral\n\n$$\n\\frac{e^{2}}{k\\pi}\\left[\nkk_F+\\frac{k_{F}^{2}-k^{2}}{kk_{F}}ln\\left\\vert\\frac{k+k_{F}}\n{k-k_{F}}\\right\\vert\n\\right],\n$$\n\nwhich gives the abovementioned expression for the single-particle energy.\n\n\n\n**b)**\nRewrite the above result as a function of the density\n\n$$\nn= \\frac{k_F^3}{3\\pi^2}=\\frac{3}{4\\pi r_s^3},\n$$\n\nwhere $n=N/V$, $N$ being the number of particles, and $r_s$ is the radius of a sphere which represents the volum per conducting electron.\n\n\n\n**Solution.**\nIntroducing the dimensionless quantity $x=k/k_F$ and the function\n\n$$\nF(x) = \\frac{1}{2}+\\frac{1-x^2}{4x}\\ln{\\left\\vert \\frac{1+x}{1-x}\\right\\vert},\n$$\n\nwe can rewrite the single-particle Hartree-Fock energy as\n\n$$\n\\varepsilon_{k}^{HF}=\\frac{\\hbar^{2}k^{2}}{2m}-\\frac{2e^{2}\nk_{F}}{\\pi}F(k/k_F),\n$$\n\nand dividing by the non-interacting contribution at the Fermi level,\n\n$$\n\\varepsilon_{0}^{F}=\\frac{\\hbar^{2}k_F^{2}}{2m},\n$$\n\nwe have\n\n$$\n\\frac{\\varepsilon_{k}^{HF} }{\\varepsilon_{0}^{F}}=x^2-\\frac{e^2m}{\\hbar^2 k_F\\pi}F(x)=x^2-\\frac{4}{\\pi k_Fa_0}F(x),\n$$\n\nwhere $a_0=0.0529$ nm is the Bohr radius, setting thereby a natural length scale. \n\n\nBy introducing the radius $r_s$ of a sphere whose volume is the volume occupied by each electron, we can rewrite the previous equation in terms of $r_s$ using that the electron density $n=N/V$\n\n$$\nn=\\frac{k_F^3}{3\\pi^2} = \\frac{3}{4\\pi r_s^3},\n$$\n\nwe have (with $k_F=1.92/r_s$,\n\n$$\n\\frac{\\varepsilon_{k}^{HF} }{\\varepsilon_{0}^{F}}=x^2-\\frac{e^2m}{\\hbar^2 k_F\\pi}F(x)=x^2-\\frac{r_s}{a_0}0.663F(x),\n$$\n\nwith $r_s \\sim 2-6$ for most metals.\n\n\n\nIt can be convenient to use the Bohr radius $a_0=\\hbar^2/e^2m$.\nFor most metals we have a relation $r_s/a_0\\sim 2-6$.\n\n**c)**\nMake a plot of the free electron energy and the Hartree-Fock energy and discuss the behavior around the Fermi surface. Extract also the Hartree-Fock band width $\\Delta\\varepsilon^{HF}$ defined as\n\n$$\n\\Delta\\varepsilon^{HF}=\\varepsilon_{k_{F}}^{HF}-\n\\varepsilon_{0}^{HF}.\n$$\n\nCompare this results with the corresponding one for a free electron and comment your results. How large is the contribution due to the exchange term in the Hartree-Fock equation?\n\n\n\n**Solution.**\nWe can now define the so-called band gap, that is the scatter between the maximal and the minimal value of the electrons in the conductance band of a metal (up to the Fermi level). \nFor $x=1$ and $r_s/a_0=4$ we have\n\n$$\n\\frac{\\varepsilon_{k=k_F}^{HF} }{\\varepsilon_{0}^{F}} = -0.326,\n$$\n\nand for $x=0$ we have\n\n$$\n\\frac{\\varepsilon_{k=0}^{HF} }{\\varepsilon_{0}^{F}} = -2.652,\n$$\n\nwhich results in a gap at the Fermi level of\n\n$$\n\\Delta \\varepsilon^{HF} = \\frac{\\varepsilon_{k=k_F}^{HF} }{\\varepsilon_{0}^{F}}-\\frac{\\varepsilon_{k=0}^{HF} }{\\varepsilon_{0}^{F}} = 2.326.\n$$\n\nThis quantity measures the deviation from the $k=0$ single-particle energy and the energy at the Fermi level.\nThe general result is\n\n$$\n\\Delta \\varepsilon^{HF} = 1+\\frac{r_s}{a_0}0.663.\n$$\n\nThe following python code produces a plot of the electron energy for a free electron (only kinetic energy) and \nfor the Hartree-Fock solution. We have chosen here a ratio $r_s/a_0=4$ and the equations are plotted as funtions\nof $k/f_F$.\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nfrom math import log\nfrom matplotlib import pyplot as plt\nfrom matplotlib import rc, rcParams\nimport matplotlib.units as units\nimport matplotlib.ticker as ticker\nrc('text',usetex=True)\nrc('font',**{'family':'serif','serif':['Hartree-Fock energy']})\nfont = {'family' : 'serif',\n 'color' : 'darkred',\n 'weight' : 'normal',\n 'size' : 16,\n }\n\nN = 100\nx = np.linspace(0.0, 2.0,N)\nF = 0.5+np.log(abs((1.0+x)/(1.0-x)))*(1.0-x*x)*0.25/x\ny = x*x -4.0*0.663*F\n\nplt.plot(x, y, 'b-')\nplt.plot(x, x*x, 'r-')\nplt.title(r'{\\bf Hartree-Fock single-particle energy for electron gas}', fontsize=20) \nplt.text(3, -40, r'Parameters: $r_s/a_0=4$', fontdict=font)\nplt.xlabel(r'$k/k_F$',fontsize=20)\nplt.ylabel(r'$\\varepsilon_k^{HF}/\\varepsilon_0^F$',fontsize=20)\n# Tweak spacing to prevent clipping of ylabel\nplt.subplots_adjust(left=0.15)\nplt.savefig('hartreefockspelgas.pdf', format='pdf')\nplt.show()\n```\n\nFrom the plot we notice that the exchange term increases considerably the band gap\ncompared with the non-interacting gas of electrons.\n\n\nWe will now define a quantity called the effective mass.\nFor $\\vert\\mathbf{k}\\vert$ near $k_{F}$, we can Taylor expand the Hartree-Fock energy as\n\n$$\n\\varepsilon_{k}^{HF}=\\varepsilon_{k_{F}}^{HF}+\n\\left(\\frac{\\partial\\varepsilon_{k}^{HF}}{\\partial k}\\right)_{k_{F}}(k-k_{F})+\\dots\n$$\n\nIf we compare the latter with the corresponding expressiyon for the non-interacting system\n\n$$\n\\varepsilon_{k}^{(0)}=\\frac{\\hbar^{2}k^{2}_{F}}{2m}+\n\\frac{\\hbar^{2}k_{F}}{m}\\left(k-k_{F}\\right)+\\dots ,\n$$\n\nwe can define the so-called effective Hartree-Fock mass as\n\n$$\nm_{HF}^{*}\\equiv\\hbar^{2}k_{F}\\left(\n\\frac{\\partial\\varepsilon_{k}^{HF}}\n{\\partial k}\\right)_{k_{F}}^{-1}\n$$\n\n**d)**\nCompute $m_{HF}^{*}$ and comment your results.\n\n**e)**\nShow that the level density (the number of single-electron states per unit energy) can be written as\n\n$$\nn(\\varepsilon)=\\frac{Vk^{2}}{2\\pi^{2}}\\left(\n\\frac{\\partial\\varepsilon}{\\partial k}\\right)^{-1}\n$$\n\nCalculate $n(\\varepsilon_{F}^{HF})$ and comment the results.\n\n\n\n\n\n\n\n\n\n\n\n## Exercise 2: Hartree-Fock ground state energy for the electron gas in three dimensions\n\nWe consider a system of electrons in infinite matter, the so-called electron gas. This is a homogeneous system and the one-particle states are given by plane wave function normalized to a volume $\\Omega$ \nfor a box with length $L$ (the limit $L\\rightarrow \\infty$ is to be taken after we have computed various expectation values)\n\n$$\n\\psi_{\\mathbf{k}\\sigma}(\\mathbf{r})= \\frac{1}{\\sqrt{\\Omega}}\\exp{(i\\mathbf{kr})}\\xi_{\\sigma}\n$$\n\nwhere $\\mathbf{k}$ is the wave number and $\\xi_{\\sigma}$ is a spin function for either spin up or down\n\n$$\n\\xi_{\\sigma=+1/2}=\\left(\\begin{array}{c} 1 \\\\ 0 \\end{array}\\right) \\hspace{0.5cm}\n\\xi_{\\sigma=-1/2}=\\left(\\begin{array}{c} 0 \\\\ 1 \\end{array}\\right).\n$$\n\nWe assume that we have periodic boundary conditions which limit the allowed wave numbers to\n\n$$\nk_i=\\frac{2\\pi n_i}{L}\\hspace{0.5cm} i=x,y,z \\hspace{0.5cm} n_i=0,\\pm 1,\\pm 2, \\dots\n$$\n\nWe assume first that the particles interact via a central, symmetric and translationally invariant\ninteraction $V(r_{12})$ with\n$r_{12}=|\\mathbf{r}_1-\\mathbf{r}_2|$. The interaction is spin independent.\n\nThe total Hamiltonian consists then of kinetic and potential energy\n\n$$\n\\hat{H} = \\hat{T}+\\hat{V}.\n$$\n\nThe operator for the kinetic energy is given by\n\n$$\n\\hat{T}=\\sum_{\\mathbf{k}\\sigma}\\frac{\\hbar^2k^2}{2m}a_{\\mathbf{k}\\sigma}^{\\dagger}a_{\\mathbf{k}\\sigma}.\n$$\n\n**a)**\nFind the expression for the interaction\n$\\hat{V}$ expressed with creation and annihilation operators. The expression for the interaction\nhas to be written in $k$ space, even though $V$ depends only on the relative distance. It means that you need to set up the Fourier transform $\\langle \\mathbf{k}_i\\mathbf{k}_j| V | \\mathbf{k}_m\\mathbf{k}_n\\rangle$.\n\n\n\n**Solution.**\nA general two-body interaction element is given by (not using anti-symmetrized matrix elements)\n\n$$\n\\hat{V} = \\frac{1}{2} \\sum_{pqrs} \\langle pq \\hat{v} \\vert rs\\rangle a_p^\\dagger a_q^\\dagger a_s a_r ,\n$$\n\nwhere $\\hat{v}$ is assumed to depend only on the relative distance between two interacting particles, that is\n$\\hat{v} = v(\\vec r_1, \\vec r_2) = v(|\\vec r_1 - \\vec r_2|) = v(r)$, with $r = |\\vec r_1 - \\vec r_2|$). \nIn our case we have, writing out explicitely the spin degrees of freedom as well\n\n\n
\n\n$$\n\\begin{equation}\n\\hat{V} = \\frac{1}{2} \\sum_{\\substack{\\sigma_p \\sigma_q \\\\ \\sigma_r \\sigma_s}}\n\\sum_{\\substack{\\mathbf{k}_p \\mathbf{k}_q \\\\ \\mathbf{k}_r \\mathbf{k}_s}}\n\\langle \\mathbf{k}_p \\sigma_p, \\mathbf{k}_q \\sigma_2\\vert v \\vert \\mathbf{k}_r \\sigma_3, \\mathbf{k}_s \\sigma_s\\rangle\na_{\\mathbf{k}_p \\sigma_p}^\\dagger a_{\\mathbf{k}_q \\sigma_q}^\\dagger a_{\\mathbf{k}_s \\sigma_s} a_{\\mathbf{k}_r \\sigma_r} .\n\\label{_auto8} \\tag{8}\n\\end{equation}\n$$\n\nInserting plane waves as eigenstates we can rewrite the matrix element as\n\n$$\n\\langle \\mathbf{k}_p \\sigma_p, \\mathbf{k}_q \\sigma_q\\vert \\hat{v} \\vert \\mathbf{k}_r \\sigma_r, \\mathbf{k}_s \\sigma_s\\rangle =\n\\frac{1}{\\Omega^2} \\delta_{\\sigma_p \\sigma_r} \\delta_{\\sigma_q \\sigma_s}\n\\int\\int \\exp{-i(\\mathbf{k}_p \\cdot \\mathbf{r}_p)} \\exp{-i( \\mathbf{k}_q \\cdot \\mathbf{r}_q)} \\hat{v}(r) \\exp{i(\\mathbf{k}_r \\cdot \\mathbf{r}_p)} \\exp{i( \\mathbf{k}_s \\cdot \\mathbf{r}_q)} d\\mathbf{r}_p d\\mathbf{r}_q ,\n$$\n\nwhere we have used the orthogonality properties of the spin functions. We change now the variables of integration\nby defining $\\mathbf{r} = \\mathbf{r}_p - \\mathbf{r}_q$, which gives $\\mathbf{r}_p = \\mathbf{r} + \\mathbf{r}_q$ and $d^3 \\mathbf{r} = d^3 \\mathbf{r}_p$. \nThe limits are not changed since they are from $-\\infty$ to $\\infty$ for all integrals. This results in\n\n$$\n\\begin{align*}\n\\langle \\mathbf{k}_p \\sigma_p, \\mathbf{k}_q \\sigma_q\\vert \\hat{v} \\vert \\mathbf{k}_r \\sigma_r, \\mathbf{k}_s \\sigma_s\\rangle\n&= \\frac{1}{\\Omega^2} \\delta_{\\sigma_p \\sigma_r} \\delta_{\\sigma_q \\sigma_s} \\int\\exp{i (\\mathbf{k}_s - \\mathbf{k}_q) \\cdot \\mathbf{r}_q} \\int v(r) \\exp{i(\\mathbf{k}_r - \\mathbf{k}_p) \\cdot ( \\mathbf{r} + \\mathbf{r}_q)} d\\mathbf{r} d\\mathbf{r}_q \\\\\n&= \\frac{1}{\\Omega^2} \\delta_{\\sigma_p \\sigma_r} \\delta_{\\sigma_q \\sigma_s} \\int v(r) \\exp{i\\left[(\\mathbf{k}_r - \\mathbf{k}_p) \\cdot \\mathbf{r}\\right]}\n\\int \\exp{i\\left[(\\mathbf{k}_s - \\mathbf{k}_q + \\mathbf{k}_r - \\mathbf{k}_p) \\cdot \\mathbf{r}_q\\right]} d\\mathbf{r}_q d\\mathbf{r} .\n\\end{align*}\n$$\n\nWe recognize the integral over $\\mathbf{r}_q$ as a $\\delta$-function, resulting in\n\n$$\n\\langle \\mathbf{k}_p \\sigma_p, \\mathbf{k}_q \\sigma_q\\vert \\hat{v} \\vert \\mathbf{k}_r \\sigma_r, \\mathbf{k}_s \\sigma_s\\rangle =\n\\frac{1}{\\Omega} \\delta_{\\sigma_p \\sigma_r} \\delta_{\\sigma_q \\sigma_s} \\delta_{(\\mathbf{k}_p + \\mathbf{k}_q),(\\mathbf{k}_r + \\mathbf{k}_s)} \\int v(r) \\exp{i\\left[(\\mathbf{k}_r - \\mathbf{k}_p) \\cdot \\mathbf{r}\\right]} d^3r .\n$$\n\nFor this equation to be different from zero, we must have conservation of momenta, we need to satisfy\n$\\mathbf{k}_p + \\mathbf{k}_q = \\mathbf{k}_r + \\mathbf{k}_s$. We can use the conservation of momenta to remove one of the summation variables resulting in\n\n$$\n\\hat{V} =\n\\frac{1}{2\\Omega} \\sum_{\\sigma \\sigma'} \\sum_{\\mathbf{k}_p \\mathbf{k}_q \\mathbf{k}_r} \\left[ \\int v(r) \\exp{i\\left[(\\mathbf{k}_r - \\mathbf{k}_p) \\cdot \\mathbf{r}\\right]} d^3r \\right]\na_{\\mathbf{k}_p \\sigma}^\\dagger a_{\\mathbf{k}_q \\sigma'}^\\dagger a_{\\mathbf{k}_p + \\mathbf{k}_q - \\mathbf{k}_r, \\sigma'} a_{\\mathbf{k}_r \\sigma},\n$$\n\nwhich can be rewritten as\n\n\n
\n\n$$\n\\begin{equation}\n\\hat{V} =\n\\frac{1}{2\\Omega} \\sum_{\\sigma \\sigma'} \\sum_{\\mathbf{k} \\mathbf{p} \\mathbf{q}} \\left[ \\int v(r) \\exp{-i( \\mathbf{q} \\cdot \\mathbf{r})} d\\mathbf{r} \\right]\na_{\\mathbf{k} + \\mathbf{q}, \\sigma}^\\dagger a_{\\mathbf{p} - \\mathbf{q}, \\sigma'}^\\dagger a_{\\mathbf{p} \\sigma'} a_{\\mathbf{k} \\sigma},\n\\label{eq:V} \\tag{9}\n\\end{equation}\n$$\n\nThis equation will be useful for our nuclear matter calculations as well. In the last equation we defined\nthe quantities\n$\\mathbf{p} = \\mathbf{k}_p + \\mathbf{k}_q - \\mathbf{k}_r$, $\\mathbf{k} = \\mathbf{k}_r$ og $\\mathbf{q} = \\mathbf{k}_p - \\mathbf{k}_r$.\n\n\n\n**b)**\nCalculate thereafter the reference energy for the infinite electron gas in three dimensions using the above expressions for the kinetic energy and the potential energy.\n\n\n\n**Solution.**\nLet us now compute the expectation value of the reference energy using the expressions for the kinetic energy operator and the interaction.\nWe need to compute $\\langle \\Phi_0\\vert \\hat{H} \\vert \\Phi_0\\rangle = \\langle \\Phi_0\\vert \\hat{T} \\vert \\Phi_0\\rangle + \\langle \\Phi_0\\vert \\hat{V} \\vert \\Phi_0\\rangle$, where $\\vert \\Phi_0\\rangle$ is our reference Slater determinant, constructed from filling all single-particle states up to the Fermi level.\nLet us start with the kinetic energy first\n\n$$\n\\langle \\Phi_0\\vert \\hat{T} \\vert \\Phi_0\\rangle \n= \\langle \\Phi_0\\vert \\left( \\sum_{\\mathbf{p} \\sigma} \\frac{\\hbar^2 p^2}{2m} a_{\\mathbf{p} \\sigma}^\\dagger a_{\\mathbf{p} \\sigma} \\right) \\vert \\Phi_0\\rangle \\\\\n= \\sum_{\\mathbf{p} \\sigma} \\frac{\\hbar^2 p^2}{2m} \\langle \\Phi_0\\vert a_{\\mathbf{p} \\sigma}^\\dagger a_{\\mathbf{p} \\sigma} \\vert \\Phi_0\\rangle .\n$$\n\nFrom the possible contractions using Wick's theorem, it is straightforward to convince oneself that the expression for the kinetic energy becomes\n\n$$\n\\langle \\Phi_0\\vert \\hat{T} \\vert \\Phi_0\\rangle = \\sum_{\\mathbf{i} \\leq F} \\frac{\\hbar^2 k_i^2}{m} = \\frac{\\Omega}{(2\\pi)^3} \\frac{\\hbar^2}{m} \\int_0^{k_F} k^2 d\\mathbf{k}.\n$$\n\nThe sum of the spin degrees of freedom results in a factor of two only if we deal with identical spin $1/2$ fermions. \nChanging to spherical coordinates, the integral over the momenta $k$ results in the final expression\n\n$$\n\\langle \\Phi_0\\vert \\hat{T} \\vert \\Phi_0\\rangle = \\frac{\\Omega}{(2\\pi)^3} \\left( 4\\pi \\int_0^{k_F} k^4 d\\mathbf{k} \\right) = \\frac{4\\pi\\Omega}{(2\\pi)^3} \\frac{1}{5} k_F^5 = \\frac{4\\pi\\Omega}{5(2\\pi)^3} k_F^5 = \\frac{\\hbar^2 \\Omega}{10\\pi^2 m} k_F^5 .\n$$\n\nThe density of states in momentum space is given by $2\\Omega/(2\\pi)^3$, where we have included the degeneracy due to the spin degrees of freedom.\nThe volume is given by $4\\pi k_F^3/3$, and the number of particles becomes\n\n$$\nN = \\frac{2\\Omega}{(2\\pi)^3} \\frac{4}{3} \\pi k_F^3 = \\frac{\\Omega}{3\\pi^2} k_F^3 \\quad \\Rightarrow \\quad\nk_F = \\left( \\frac{3\\pi^2 N}{\\Omega} \\right)^{1/3}.\n$$\n\nThis gives us\n\n\n
\n\n$$\n\\begin{equation}\n\\langle \\Phi_0\\vert \\hat{T} \\vert \\Phi_0\\rangle =\n\\frac{\\hbar^2 \\Omega}{10\\pi^2 m} \\left( \\frac{3\\pi^2 N}{\\Omega} \\right)^{5/3} =\n\\frac{\\hbar^2 (3\\pi^2)^{5/3} N}{10\\pi^2 m} \\rho^{2/3} ,\n\\label{eq:T_forventning} \\tag{10}\n\\end{equation}\n$$\n\nWe are now ready to calculate the expectation value of the potential energy\n\n$$\n\\begin{align*}\n\\langle \\Phi_0\\vert \\hat{V} \\vert \\Phi_0\\rangle \n&= \\langle \\Phi_0\\vert \\left( \\frac{1}{2\\Omega} \\sum_{\\sigma \\sigma'} \\sum_{\\mathbf{k} \\mathbf{p} \\mathbf{q} } \\left[ \\int v(r) \\exp{-i (\\mathbf{q} \\cdot \\mathbf{r})} d\\mathbf{r} \\right] a_{\\mathbf{k} + \\mathbf{q}, \\sigma}^\\dagger a_{\\mathbf{p} - \\mathbf{q}, \\sigma'}^\\dagger a_{\\mathbf{p} \\sigma'} a_{\\mathbf{k} \\sigma} \\right) \\vert \\Phi_0\\rangle \\\\\n&= \\frac{1}{2\\Omega} \\sum_{\\sigma \\sigma'} \\sum_{\\mathbf{k} \\mathbf{p} \\mathbf{q}} \\left[ \\int v(r) \\exp{-i (\\mathbf{q} \\cdot \\mathbf{r})} d\\mathbf{r} \\right]\\langle \\Phi_0\\vert a_{\\mathbf{k} + \\mathbf{q}, \\sigma}^\\dagger a_{\\mathbf{p} - \\mathbf{q}, \\sigma'}^\\dagger a_{\\mathbf{p} \\sigma'} a_{\\mathbf{k} \\sigma} \\vert \\Phi_0\\rangle .\n\\end{align*}\n$$\n\nThe only contractions which result in non-zero results are those that involve states below the Fermi level, that is \n$k \\leq k_F$, $p \\leq k_F$, $|\\mathbf{p} - \\mathbf{q}| < \\mathbf{k}_F$ and $|\\mathbf{k} + \\mathbf{q}| \\leq k_F$. Due to momentum conservation we must also have $\\mathbf{k} + \\mathbf{q} = \\mathbf{p}$, $\\mathbf{p} - \\mathbf{q} = \\mathbf{k}$ and $\\sigma = \\sigma'$ or $\\mathbf{k} + \\mathbf{q} = \\mathbf{k}$ and $\\mathbf{p} - \\mathbf{q} = \\mathbf{p}$. \nSummarizing, we must have\n\n$$\n\\mathbf{k} + \\mathbf{q} = \\mathbf{p} \\quad \\text{and} \\quad \\sigma = \\sigma', \\qquad\n\\text{or} \\qquad\n\\mathbf{q} = \\mathbf{0} .\n$$\n\nWe obtain then\n\n$$\n\\langle \\Phi_0\\vert \\hat{V} \\vert \\Phi_0\\rangle =\n\\frac{1}{2\\Omega} \\left( \\sum_{\\sigma \\sigma'} \\sum_{\\mathbf{q} \\mathbf{p} \\leq F} \\left[ \\int v(r) d\\mathbf{r} \\right] - \\sum_{\\sigma}\n\\sum_{\\mathbf{q} \\mathbf{p} \\leq F} \\left[ \\int v(r) \\exp{-i (\\mathbf{q} \\cdot \\mathbf{r})} d\\mathbf{r} \\right] \\right).\n$$\n\nThe first term is the so-called direct term while the second term is the exchange term. \nWe can rewrite this equation as (and this applies to any potential which depends only on the relative distance between particles)\n\n\n
\n\n$$\n\\begin{equation}\n\\langle \\Phi_0\\vert \\hat{V} \\vert \\Phi_0\\rangle =\n\\frac{1}{2\\Omega} \\left( N^2 \\left[ \\int v(r) d\\mathbf{r} \\right] - N \\sum_{\\mathbf{q}} \\left[ \\int v(r) \\exp{-i (\\mathbf{q}\\cdot \\mathbf{r})} d\\mathbf{r} \\right] \\right),\n\\label{eq:V_b} \\tag{11}\n\\end{equation}\n$$\n\nwhere we have used the fact that a sum like $\\sum_{\\sigma}\\sum_{\\mathbf{k}}$ equals the number of particles. Using the fact that the density is given by\n$\\rho = N/\\Omega$, with $\\Omega$ being our volume, we can rewrite the last equation as\n\n$$\n\\langle \\Phi_0\\vert \\hat{V} \\vert \\Phi_0\\rangle =\n\\frac{1}{2} \\left( \\rho N \\left[ \\int v(r) d\\mathbf{r} \\right] - \\rho\\sum_{\\mathbf{q}} \\left[ \\int v(r) \\exp{-i (\\mathbf{q}\\cdot \\mathbf{r})} d\\mathbf{r} \\right] \\right).\n$$\n\nFor the electron gas\nthe interaction part of the Hamiltonian operator is given by\n\n$$\n\\hat{H}_I=\\hat{H}_{el}+\\hat{H}_{b}+\\hat{H}_{el-b},\n$$\n\nwith the electronic part\n\n$$\n\\hat{H}_{el}=\\sum_{i=1}^N\\frac{p_i^2}{2m}+\\frac{e^2}{2}\\sum_{i\\ne j}\\frac{e^{-\\mu |\\mathbf{r}_i-\\mathbf{r}_j|}}{|\\mathbf{r}_i-\\mathbf{r}_j|},\n$$\n\nwhere we have introduced an explicit convergence factor\n(the limit $\\mu\\rightarrow 0$ is performed after having calculated the various integrals).\nCorrespondingly, we have\n\n$$\n\\hat{H}_{b}=\\frac{e^2}{2}\\int\\int d\\mathbf{r}d\\mathbf{r}'\\frac{n(\\mathbf{r})n(\\mathbf{r}')e^{-\\mu |\\mathbf{r}-\\mathbf{r}'|}}{|\\mathbf{r}-\\mathbf{r}'|},\n$$\n\nwhich is the energy contribution from the positive background charge with density\n$n(\\mathbf{r})=N/\\Omega$. Finally,\n\n$$\n\\hat{H}_{el-b}=-\\frac{e^2}{2}\\sum_{i=1}^N\\int d\\mathbf{r}\\frac{n(\\mathbf{r})e^{-\\mu |\\mathbf{r}-\\mathbf{x}_i|}}{|\\mathbf{r}-\\mathbf{x}_i|},\n$$\n\nis the interaction between the electrons and the positive background.\nWe can show that\n\n$$\n\\hat{H}_{b}=\\frac{e^2}{2}\\frac{N^2}{\\Omega}\\frac{4\\pi}{\\mu^2},\n$$\n\nand\n\n$$\n\\hat{H}_{el-b}=-e^2\\frac{N^2}{\\Omega}\\frac{4\\pi}{\\mu^2}.\n$$\n\nFor the electron gas and a Coulomb interaction, these two terms are cancelled (in the thermodynamic limit) by the contribution from the direct term arising\nfrom the repulsive electron-electron interaction. What remains then when computing the reference energy is only the kinetic energy contribution and the contribution from the exchange term. For other interactions, like nuclear forces with a short range part and no infinite range, we need to compute both the direct term and the exchange term.\n\n\n\n**c)**\nShow thereafter that the final Hamiltonian can be written as\n\n$$\nH=H_{0}+H_{I},\n$$\n\nwith\n\n$$\nH_{0}={\\displaystyle\\sum_{\\mathbf{k}\\sigma}}\n\\frac{\\hbar^{2}k^{2}}{2m}a_{\\mathbf{k}\\sigma}^{\\dagger}\na_{\\mathbf{k}\\sigma},\n$$\n\nand\n\n$$\nH_{I}=\\frac{e^{2}}{2\\Omega}{\\displaystyle\\sum_{\\sigma_{1}\\sigma_{2}}}{\\displaystyle\\sum_{\\mathbf{q}\\neq 0,\\mathbf{k},\\mathbf{p}}}\\frac{4\\pi}{q^{2}}\na_{\\mathbf{k}+\\mathbf{q},\\sigma_{1}}^{\\dagger}\na_{\\mathbf{p}-\\mathbf{q},\\sigma_{2}}^{\\dagger}\na_{\\mathbf{p}\\sigma_{2}}a_{\\mathbf{k}\\sigma_{1}}.\n$$\n\n**d)**\nCalculate $E_0/N=\\langle \\Phi_{0}\\vert H\\vert \\Phi_{0}\\rangle/N$ for for this system to first order in the interaction. Show that, by using\n\n$$\n\\rho= \\frac{k_F^3}{3\\pi^2}=\\frac{3}{4\\pi r_0^3},\n$$\n\nwith $\\rho=N/\\Omega$, $r_0$\nbeing the radius of a sphere representing the volume an electron occupies \nand the Bohr radius $a_0=\\hbar^2/e^2m$, \nthat the energy per electron can be written as\n\n$$\nE_0/N=\\frac{e^2}{2a_0}\\left[\\frac{2.21}{r_s^2}-\\frac{0.916}{r_s}\\right].\n$$\n\nHere we have defined\n$r_s=r_0/a_0$ to be a dimensionless quantity.\n\n**e)**\nPlot your results. Why is this system stable?\nCalculate thermodynamical quantities like the pressure, given by\n\n$$\nP=-\\left(\\frac{\\partial E}{\\partial \\Omega}\\right)_N,\n$$\n\nand the bulk modulus\n\n$$\nB=-\\Omega\\left(\\frac{\\partial P}{\\partial \\Omega}\\right)_N,\n$$\n\nand comment your results.\n\n\n\n\n\n\n\n\n## Preparing the ground for numerical calculations; kinetic energy and Ewald term\n\nThe kinetic energy operator is\n\n\n
\n\n$$\n\\begin{equation}\n \\hat{H}_{\\text{kin}} = -\\frac{\\hbar^{2}}{2m}\\sum_{i=1}^{N}\\nabla_{i}^{2},\n\\label{_auto9} \\tag{12}\n\\end{equation}\n$$\n\nwhere the sum is taken over all particles in the finite\nbox. The Ewald electron-electron interaction operator \ncan be written as\n\n\n
\n\n$$\n\\begin{equation}\n \\hat{H}_{ee} = \\sum_{i < j}^{N} v_{E}\\left( \\mathbf{r}_{i}-\\mathbf{r}_{j}\\right)\n + \\frac{1}{2}Nv_{0},\n\\label{_auto10} \\tag{13}\n\\end{equation}\n$$\n\nwhere $v_{E}(\\mathbf{r})$ is the effective two-body \ninteraction and $v_{0}$ is the self-interaction, defined \nas $v_{0} = \\lim_{\\mathbf{r} \\rightarrow 0} \\left\\{ v_{E}(\\mathbf{r}) - 1/r\\right\\} $. \n\nThe negative \nelectron charges are neutralized by a positive, homogeneous \nbackground charge. Fraser *et al.* explain how the\nelectron-background and background-background terms, \n$\\hat{H}_{eb}$ and $\\hat{H}_{bb}$, vanish\nwhen using Ewald's interaction for the three-dimensional\nelectron gas. Using the same arguments, one can show that\nthese terms are also zero in the corresponding \ntwo-dimensional system. \n\n\n\n\n## Ewald correction term\n\nIn the three-dimensional electron gas, the Ewald \ninteraction is\n\n$$\nv_{E}(\\mathbf{r}) = \\sum_{\\mathbf{k} \\neq \\mathbf{0}}\n \\frac{4\\pi }{L^{3}k^{2}}e^{i\\mathbf{k}\\cdot \\mathbf{r}}\n e^{-\\eta^{2}k^{2}/4} \\nonumber\n$$\n\n\n
\n\n$$\n\\begin{equation} \n + \\sum_{\\mathbf{R}}\\frac{1}{\\left| \\mathbf{r}\n -\\mathbf{R}\\right| } \\mathrm{erfc} \\left( \\frac{\\left| \n \\mathbf{r}-\\mathbf{R}\\right|}{\\eta }\\right)\n - \\frac{\\pi \\eta^{2}}{L^{3}},\n\\label{_auto11} \\tag{14}\n\\end{equation}\n$$\n\nwhere $L$ is the box side length, $\\mathrm{erfc}(x)$ is the \ncomplementary error function, and $\\eta $ is a free\nparameter that can take any value in the interval \n$(0, \\infty )$.\n\n\n\n## Interaction in momentum space\n\nThe translational vector\n\n\n
\n\n$$\n\\begin{equation}\n \\mathbf{R} = L\\left(n_{x}\\mathbf{u}_{x} + n_{y}\n \\mathbf{u}_{y} + n_{z}\\mathbf{u}_{z}\\right) ,\n\\label{_auto12} \\tag{15}\n\\end{equation}\n$$\n\nwhere $\\mathbf{u}_{i}$ is the unit vector for dimension $i$,\nis defined for all integers $n_{x}$, $n_{y}$, and \n$n_{z}$. These vectors are used to obtain all image\ncells in the entire real space. \nThe parameter $\\eta $ decides how \nthe Coulomb interaction is divided into a short-ranged\nand long-ranged part, and does not alter the total\nfunction. However, the number of operations needed\nto calculate the Ewald interaction with a desired \naccuracy depends on $\\eta $, and $\\eta $ is therefore \noften chosen to optimize the convergence as a function\nof the simulation-cell size. In\nour calculations, we choose $\\eta $ to be an infinitesimally\nsmall positive number, similarly as was done by [Shepherd *et al.*](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.86.035111) and [Roggero *et al.*](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.88.115138).\n\nThis gives an interaction that is evaluated only in\nFourier space. \n\nWhen studying the two-dimensional electron gas, we\nuse an Ewald interaction that is quasi two-dimensional.\nThe interaction is derived in three dimensions, with \nFourier discretization in only two dimensions. The Ewald effective\ninteraction has the form\n\n$$\nv_{E}(\\mathbf{r}) = \\sum_{\\mathbf{k} \\neq \\mathbf{0}} \n \\frac{\\pi }{L^{2}k}\\left\\{ e^{-kz} \\mathrm{erfc} \\left(\n \\frac{\\eta k}{2} - \\frac{z}{\\eta }\\right)+ \\right. \\nonumber\n$$\n\n$$\n\\left. e^{kz}\\mathrm{erfc} \\left( \\frac{\\eta k}{2} + \\frac{z}{\\eta }\n \\right) \\right\\} e^{i\\mathbf{k}\\cdot \\mathbf{r}_{xy}} \n \\nonumber\n$$\n\n$$\n+ \\sum_{\\mathbf{R}}\\frac{1}{\\left| \\mathbf{r}-\\mathbf{R}\n \\right| } \\mathrm{erfc} \\left( \\frac{\\left| \\mathbf{r}-\\mathbf{R}\n \\right|}{\\eta }\\right) \\nonumber\n$$\n\n\n
\n\n$$\n\\begin{equation} \n - \\frac{2\\pi}{L^{2}}\\left\\{ z\\mathrm{erf} \\left( \\frac{z}{\\eta }\n \\right) + \\frac{\\eta }{\\sqrt{\\pi }}e^{-z^{2}/\\eta^{2}}\\right\\},\n\\label{_auto13} \\tag{16}\n\\end{equation}\n$$\n\nwhere the Fourier vectors $\\mathbf{k}$ and the position vector\n$\\mathbf{r}_{xy}$ are defined in the $(x,y)$ plane. When\napplying the interaction $v_{E}(\\mathbf{r})$ to two-dimensional\nsystems, we set $z$ to zero. \n\n\nSimilarly as in the \nthree-dimensional case, also here we \nchoose $\\eta $ to approach zero from above. The resulting \nFourier-transformed interaction is\n\n\n
\n\n$$\n\\begin{equation}\n v_{E}^{\\eta = 0, z = 0}(\\mathbf{r}) = \\sum_{\\mathbf{k} \\neq \\mathbf{0}} \n \\frac{2\\pi }{L^{2}k}e^{i\\mathbf{k}\\cdot \\mathbf{r}_{xy}}. \n\\label{_auto14} \\tag{17}\n\\end{equation}\n$$\n\nThe self-interaction $v_{0}$ is a constant that can be \nincluded in the reference energy.\n\n\n\n\n## Antisymmetrized matrix elements in three dimensions\n\nIn the three-dimensional electron gas, the antisymmetrized\nmatrix elements are\n\n\n
\n\n$$\n\\label{eq:vmat_3dheg} \\tag{18}\n \\langle \\mathbf{k}_{p}m_{s_{p}}\\mathbf{k}_{q}m_{s_{q}}\n |\\tilde{v}|\\mathbf{k}_{r}m_{s_{r}}\\mathbf{k}_{s}m_{s_{s}}\\rangle_{AS} \n \\nonumber\n$$\n\n$$\n= \\frac{4\\pi }{L^{3}}\\delta_{\\mathbf{k}_{p}+\\mathbf{k}_{q},\n \\mathbf{k}_{r}+\\mathbf{k}_{s}}\\left\\{ \n \\delta_{m_{s_{p}}m_{s_{r}}}\\delta_{m_{s_{q}}m_{s_{s}}}\n \\left( 1 - \\delta_{\\mathbf{k}_{p}\\mathbf{k}_{r}}\\right) \n \\frac{1}{|\\mathbf{k}_{r}-\\mathbf{k}_{p}|^{2}}\n \\right. \\nonumber\n$$\n\n\n
\n\n$$\n\\begin{equation} \n \\left. - \\delta_{m_{s_{p}}m_{s_{s}}}\\delta_{m_{s_{q}}m_{s_{r}}}\n \\left( 1 - \\delta_{\\mathbf{k}_{p}\\mathbf{k}_{s}} \\right)\n \\frac{1}{|\\mathbf{k}_{s}-\\mathbf{k}_{p}|^{2}} \n \\right\\} ,\n\\label{_auto15} \\tag{19}\n\\end{equation}\n$$\n\nwhere the Kronecker delta functions \n$\\delta_{\\mathbf{k}_{p}\\mathbf{k}_{r}}$ and\n$\\delta_{\\mathbf{k}_{p}\\mathbf{k}_{s}}$ ensure that the \ncontribution with zero momentum transfer vanishes.\n\n\nSimilarly, the matrix elements for the two-dimensional\nelectron gas are\n\n\n
\n\n$$\n\\label{eq:vmat_2dheg} \\tag{20}\n \\langle \\mathbf{k}_{p}m_{s_{p}}\\mathbf{k}_{q}m_{s_{q}}\n |v|\\mathbf{k}_{r}m_{s_{r}}\\mathbf{k}_{s}m_{s_{s}}\\rangle_{AS} \n \\nonumber\n$$\n\n$$\n= \\frac{2\\pi }{L^{2}}\n \\delta_{\\mathbf{k}_{p}+\\mathbf{k}_{q},\\mathbf{k}_{r}+\\mathbf{k}_{s}}\n \\left\\{ \\delta_{m_{s_{p}}m_{s_{r}}}\\delta_{m_{s_{q}}m_{s_{s}}} \n \\left( 1 - \\delta_{\\mathbf{k}_{p}\\mathbf{k}_{r}}\\right)\n \\frac{1}{\n |\\mathbf{k}_{r}-\\mathbf{k}_{p}|} \\right.\n \\nonumber\n$$\n\n\n
\n\n$$\n\\begin{equation} \n - \\left. \\delta_{m_{s_{p}}m_{s_{s}}}\\delta_{m_{s_{q}}m_{s_{r}}}\n \\left( 1 - \\delta_{\\mathbf{k}_{p}\\mathbf{k}_{s}}\\right)\n \\frac{1}{ \n |\\mathbf{k}_{s}-\\mathbf{k}_{p}|}\n \\right\\} ,\n\\label{_auto16} \\tag{21}\n\\end{equation}\n$$\n\nwhere the single-particle momentum vectors $\\mathbf{k}_{p,q,r,s}$\nare now defined in two dimensions.\n\nIn actual calculations, the \nsingle-particle energies, defined by the operator $\\hat{f}$, are given by\n\n\n
\n\n$$\n\\begin{equation}\n \\langle \\mathbf{k}_{p}|f|\\mathbf{k}_{q} \\rangle\n = \\frac{\\hbar^{2}k_{p}^{2}}{2m}\\delta_{\\mathbf{k}_{p},\n \\mathbf{k}_{q}} + \\sum_{\\mathbf{k}_{i}}\\langle \n \\mathbf{k}_{p}\\mathbf{k}_{i}|v|\\mathbf{k}_{q}\n \\mathbf{k}_{i}\\rangle_{AS}.\n\\label{eq:fock_heg} \\tag{22}\n\\end{equation}\n$$\n\n## Periodic boundary conditions and single-particle states\n\nWhen using periodic boundary conditions, the \ndiscrete-momentum single-particle basis functions\n\n$$\n\\phi_{\\mathbf{k}}(\\mathbf{r}) =\ne^{i\\mathbf{k}\\cdot \\mathbf{r}}/L^{d/2}\n$$\n\nare associated with \nthe single-particle energy\n\n\n
\n\n$$\n\\begin{equation}\n \\varepsilon_{n_{x}, n_{y}} = \\frac{\\hbar^{2}}{2m} \\left( \\frac{2\\pi }{L}\\right)^{2}\\left( n_{x}^{2} + n_{y}^{2}\\right)\n\\label{_auto17} \\tag{23}\n\\end{equation}\n$$\n\nfor two-dimensional sytems and\n\n\n
\n\n$$\n\\begin{equation}\n \\varepsilon_{n_{x}, n_{y}, n_{z}} = \\frac{\\hbar^{2}}{2m}\n \\left( \\frac{2\\pi }{L}\\right)^{2}\n \\left( n_{x}^{2} + n_{y}^{2} + n_{z}^{2}\\right)\n\\label{_auto18} \\tag{24}\n\\end{equation}\n$$\n\nfor three-dimensional systems.\n\n\nWe choose the single-particle basis such that both the occupied and \nunoccupied single-particle spaces have a closed-shell \nstructure. This means that all single-particle states \ncorresponding to energies below a chosen cutoff are\nincluded in the basis. We study only the unpolarized spin\nphase, in which all orbitals are occupied with one spin-up \nand one spin-down electron. \n\n\nThe table illustrates how single-particle energies\n fill energy shells in a two-dimensional electron box.\n Here $n_{x}$ and $n_{y}$ are the momentum quantum numbers,\n $n_{x}^{2} + n_{y}^{2}$ determines the single-particle \n energy level, $N_{\\uparrow \\downarrow }$ represents the \n cumulated number of spin-orbitals in an unpolarized spin\n phase, and $N_{\\uparrow \\uparrow }$ stands for the\n cumulated number of spin-orbitals in a spin-polarized\n system.\n\n\n\n\n## Magic numbers for the two-dimensional electron gas\n\n\n\n\n$n_{x}^{2}+n_{y}^{2}$ $n_{x}$ $n_{y}$ $N_{\\uparrow \\downarrow }$ $N_{\\uparrow \\uparrow }$ \n\n 0 0 0 2 1 1 -1 0 1 0 0 -1 0 1 10 5 2 -1 -1 -1 1 1 -1 1 1 18 9 4 -2 0 2 0 0 -2 0 2 26 13 5 -2 -1 2 -1 -2 1 2 1 -1 -2 -1 2 1 -2 1 2 42 21 \n
\n## Hartree-Fock energies\n\nFinally, a useful benchmark for our calculations is the expression for\nthe reference energy $E_0$ per particle.\nDefining the $T=0$ density $\\rho_0$, we can in turn determine in three\ndimensions the radius $r_0$ of a sphere representing the volume an\nelectron occupies (the classical electron radius) as\n\n$$\nr_0= \\left(\\frac{3}{4\\pi \\rho}\\right)^{1/3}.\n$$\n\nIn two dimensions the corresponding quantity is\n\n$$\nr_0= \\left(\\frac{1}{\\pi \\rho}\\right)^{1/2}.\n$$\n\nOne can then express the reference energy per electron in terms of the\ndimensionless quantity $r_s=r_0/a_0$, where we have introduced the\nBohr radius $a_0=\\hbar^2/e^2m$. The energy per electron computed with\nthe reference Slater determinant can then be written as\n(using hereafter only atomic units, meaning that $\\hbar = m = e = 1$)\n\n$$\ng\nE_0/N=\\frac{1}{2}\\left[\\frac{2.21}{r_s^2}-\\frac{0.916}{r_s}\\right],\n$$\n\nfor the three-dimensional electron gas. For the two-dimensional gas\nthe corresponding expression is (show this)\n\n$$\nE_0/N=\\frac{1}{r_s^2}-\\frac{8\\sqrt{2}}{3\\pi r_s}.a\n$$\n\nFor an infinite homogeneous system, there are some particular\nsimplications due to the conservation of the total momentum of the\nparticles. By symmetry considerations, the total momentum of the\nsystem has to be zero. Both the kinetic energy operator and the\ntotal Hamiltonian $\\hat{H}$ are assumed to be diagonal in the total\nmomentum $\\mathbf{K}$. Hence, both the reference state $\\Phi_{0}$ and\nthe correlated ground state $\\Psi$ must be eigenfunctions of the\noperator $\\mathbf{\\hat{K}}$ with the corresponding eigemnvalue\n$\\mathbf{K} = \\mathbf{0}$. This leads to important\nsimplications to our different many-body methods. In coupled cluster\ntheory for example, all\nterms that involve single particle-hole excitations vanish. \n\n\n\n\n\n## Exercise 3: Magic numbers for the three-dimensional electron gas and perturbation theory to second order\n\n\n**a)**\nSet up the possible magic numbers for the electron gas in three dimensions using periodic boundary conditions..\n\n\n\n**Hint.**\nFollow the example for the two-dimensional electron gas and add the third dimension via the quantum number $n_z$.\n\n\n\n\n\n**Solution.**\nUsing the same approach as made with the two-dimensional electron gas with the single-particle kinetic energy defined as\n\n$$\n\\frac{\\hbar^2}{2m}\\left(k_{n_x}^2+k_{n_y}^2k_{n_z}^2\\right),\n$$\n\nand\n\n$$\nk_{n_i}=\\frac{2\\pi n_i}{L} \\hspace{0.1cm} n_i = 0, \\pm 1, \\pm 2, \\dots,\n$$\n\nwe can set up a similar table and obtain (assuming identical particles one and including spin up and spin down solutions) for energies less than or equal to $n_{x}^{2}+n_{y}^{2}+n_{z}^{2}\\le 3$\n\n\n\n$n_{x}^{2}+n_{y}^{2}+n_{z}^{2}$ $n_{x}$ $n_{y}$ $n_{z}$ $N_{\\uparrow \\downarrow }$ \n\n 0 0 0 0 2 1 -1 0 0 1 1 0 0 1 0 -1 0 1 0 1 0 1 0 0 -1 1 0 0 1 14 2 -1 -1 0 2 -1 1 0 2 1 -1 0 2 1 1 0 2 -1 0 -1 2 -1 0 1 2 1 0 -1 2 1 0 1 2 0 -1 -1 2 0 -1 1 2 0 1 -1 2 0 1 1 38 3 -1 -1 -1 3 -1 -1 1 3 -1 1 -1 3 -1 1 1 3 1 -1 -1 3 1 -1 1 3 1 1 -1 3 1 1 1 54 \n
\nContinuing in this way we get for $n_{x}^{2}+n_{y}^{2}+n_{z}^{2}=4$ a total of 22 additional states, resulting in $76$ as a new magic number. For the lowest six energy values the degeneracy in energy gives us $2$, $14$, $38$, $54$, $76$ and $114$ as magic numbers. These numbers will then define our Fermi level when we compute the energy in a Cartesian basis. When performing calculations based on many-body perturbation theory, Coupled cluster theory or other many-body methods, we need then to add states above the Fermi level in order to sum over single-particle states which are not occupied. \n\nIf we wish to study infinite nuclear matter with both protons and neutrons, the above magic numbers become $4, 28, 76, 108, 132, 228, \\dots$.\n\n\n\n**b)**\nEvery number of particles for filled shells defines also the number of particles to be used in a given calculation. Use the number of particles to define the density of the system\n\n$$\n\\rho = g \\frac{k_F^3}{6\\pi^2},\n$$\n\nwhere you need to define $k_F$ and the degeneracy $g$, which is two for one type of spin-$1/2$ particles and four for symmetric nuclear matter.\n\n**c)**\nUse the density to find the length $L$ of the box used with periodic boundary contributions, that is use the relation\n\n$$\nV= L^3= \\frac{A}{\\rho}.\n$$\n\nYou can use $L$ to define the spacing to set up the spacing between varipus $k$-values, that is\n\n$$\n\\Delta k = \\frac{2\\pi}{L}.\n$$\n\nHere, $A$ can be the number of nucleons. If we deal with the electron gas only, this needs to be replaced by the number of electrons $N$.\n\n**d)**\nCalculate thereafter the Hartree-Fock total energy for the electron gas or infinite nuclear matter using the Minnesota interaction discussed during the lectures. Compare the results with the exact Hartree-Fock results for the electron gas as a function of the number of particles.\n\n**e)**\nCompute now the contribution to the correlation energy for the electron gas at the level of second-order perturbation theory using a given number of electrons $N$ and a given (defined by you) number of single-particle states above the Fermi level.\nThe following Python code shows an implementation for the electron gas in three dimensions for second perturbation theory using the Coulomb interaction. Here we have hard-coded a case which computes the energy for $N=14$ and a total of $5$ major shells.\n\n\n\n**Solution.**\n\n\n```python\nfrom numpy import *\n\nclass electronbasis():\n def __init__(self, N, rs, Nparticles):\n ############################################################\n ##\n ## Initialize basis: \n ## N = number of shells\n ## rs = parameter for volume \n ## Nparticles = Number of holes (conflicting naming, sorry)\n ##\n ###########################################################\n \n self.rs = rs\n self.states = []\n self.nstates = 0\n self.nparticles = Nparticles\n self.nshells = N - 1\n self.Nm = N + 1\n \n self.k_step = 2*(self.Nm + 1)\n Nm = N\n n = 0 #current shell\n ene_integer = 0\n while n <= self.nshells:\n is_shell = False\n for x in range(-Nm, Nm+1):\n for y in range(-Nm, Nm+1):\n for z in range(-Nm,Nm+1):\n e = x*x + y*y + z*z\n if e == ene_integer:\n is_shell = True\n self.nstates += 2\n self.states.append([e, x,y,z,1])\n self.states.append([e, x,y,z, -1])\n \n if is_shell:\n n += 1\n ene_integer += 1\n self.L3 = (4*pi*self.nparticles*self.rs**3)/3.0\n self.L2 = self.L3**(2/3.0)\n self.L = pow(self.L3, 1/3.0)\n \n for i in range(self.nstates):\n self.states[i][0] *= 2*(pi**2)/self.L**2 #Multiplying in the missing factors in the single particle energy\n self.states = array(self.states) #converting to array to utilize vectorized calculations \n \n def hfenergy(self, nParticles):\n #Calculate the HF-energy (reference energy) for nParticles particles\n e0 = 0.0\n if nParticles<=self.nstates:\n for i in range(nParticles):\n e0 += self.h(i,i)\n for j in range(nParticles):\n if j != i:\n e0 += .5*self.v(i,j,i,j)\n else:\n #Safety for cases where nParticles exceeds size of basis\n print \"Not enough basis states.\"\n \n return e0\n \n def h(self, p,q):\n #Return single particle energy\n return self.states[p,0]*(p==q)\n\n \n def v(self,p,q,r,s):\n #Two body interaction for electron gas\n val = 0\n terms = 0.0\n term1 = 0.0\n term2 = 0.0\n kdpl = self.kdplus(p,q,r,s)\n if kdpl != 0:\n val = 1.0/self.L3\n if self.kdspin(p,r)*self.kdspin(q,s)==1:\n if self.kdwave(p,r) != 1.0:\n term1 = self.L2/(pi*self.absdiff2(r,p))\n if self.kdspin(p,s)*self.kdspin(q,r)==1:\n if self.kdwave(p,s) != 1.0:\n term2 = self.L2/(pi*self.absdiff2(s,p))\n return val*(term1-term2)\n\n \n #The following is a series of kroenecker deltas used in the two-body interactions. \n #Just ignore these lines unless you suspect an error here\n def kdi(self,a,b):\n #Kroenecker delta integer\n return 1.0*(a==b)\n def kda(self,a,b):\n #Kroenecker delta array\n d = 1.0\n #print a,b,\n for i in range(len(a)):\n d*=(a[i]==b[i])\n return d\n def kdfullplus(self,p,q,r,s):\n #Kroenecker delta wavenumber p+q,r+s\n return self.kda(self.states[p][1:5]+self.states[q][1:5],self.states[r][1:5]+self.states[s][1:5])\n def kdplus(self,p,q,r,s):\n #Kroenecker delta wavenumber p+q,r+s\n return self.kda(self.states[p][1:4]+self.states[q][1:4],self.states[r][1:4]+self.states[s][1:4])\n def kdspin(self,p,q):\n #Kroenecker delta spin\n return self.kdi(self.states[p][4], self.states[q][4])\n def kdwave(self,p,q):\n #Kroenecker delta wavenumber\n return self.kda(self.states[p][1:4],self.states[q][1:4])\n def absdiff2(self,p,q):\n val = 0.0\n for i in range(1,4):\n val += (self.states[p][i]-self.states[q][i])*(self.states[p][i]-self.states[q][i])\n return val\n\n \ndef MBPT2(bs):\n #2. order MBPT Energy \n Nh = bs.nparticles\n Np = bs.nstates-bs.nparticles #Note the conflicting notation here. bs.nparticles is number of hole states \n vhhpp = zeros((Nh**2, Np**2))\n vpphh = zeros((Np**2, Nh**2))\n #manual MBPT(2) energy (Should be -0.525588309385 for 66 states, shells = 5, in this code)\n psum2 = 0\n for i in range(Nh):\n for j in range(Nh):\n for a in range(Np):\n for b in range(Np):\n #val1 = bs.v(i,j,a+Nh,b+Nh)\n #val2 = bs.v(a+Nh,b+Nh,i,j)\n #if val1!=val2:\n # print val1, val2\n vhhpp[i + j*Nh, a+b*Np] = bs.v(i,j,a+Nh,b+Nh)\n vpphh[a+b*Np,i + j*Nh] = bs.v(a+Nh,b+Nh,i,j)/(bs.states[i,0] + bs.states[j,0] - bs.states[a + Nh, 0] - bs.states[b+Nh,0])\n psum = .25*sum(dot(vhhpp,vpphh).diagonal())\n return psum\n \ndef MBPT2_fast(bs):\n #2. order MBPT Energy \n Nh = bs.nparticles\n Np = bs.nstates-bs.nparticles #Note the conflicting notation here. bs.nparticles is number of hole states \n vhhpp = zeros((Nh**2, Np**2))\n vpphh = zeros((Np**2, Nh**2))\n #manual MBPT(2) energy (Should be -0.525588309385 for 66 states, shells = 5, in this code)\n psum2 = 0\n for i in range(Nh):\n for j in range(i):\n for a in range(Np):\n for b in range(a):\n val = bs.v(i,j,a+Nh,b+Nh)\n eps = val/(bs.states[i,0] + bs.states[j,0] - bs.states[a + Nh, 0] - bs.states[b+Nh,0])\n vhhpp[i + j*Nh, a+b*Np] = val \n vhhpp[j + i*Nh, a+b*Np] = -val \n vhhpp[i + j*Nh, b+a*Np] = -val\n vhhpp[j + i*Nh, b+a*Np] = val \n \n \n vpphh[a+b*Np,i + j*Nh] = eps\n vpphh[a+b*Np,j + i*Nh] = -eps\n vpphh[b+a*Np,i + j*Nh] = -eps\n vpphh[b+a*Np,j + i*Nh] = eps\n \n \n psum = .25*sum(dot(vhhpp,vpphh).diagonal())\n return psum\n\n\n#user input here\nnumber_of_shells = 5\nnumber_of_holes = 14 #(particles)\n\n\n#initialize basis \nbs = electronbasis(number_of_shells,1.0,number_of_holes) #shells, r_s = 1.0, holes\n\n#Print some info to screen\nprint \"Number of shells:\", number_of_shells\nprint \"Number of states:\", bs.nstates\nprint \"Number of holes :\", bs.nparticles\nprint \"Reference Energy:\", bs.hfenergy(number_of_holes), \"hartrees \"\nprint \" :\", 2*bs.hfenergy(number_of_holes), \"rydbergs \"\n\nprint \"Ref.E. per hole :\", bs.hfenergy(number_of_holes)/number_of_holes, \"hartrees \"\nprint \" :\", 2*bs.hfenergy(number_of_holes)/number_of_holes, \"rydbergs \"\n\n\n\n#calculate MBPT2 energy\nprint \"MBPT2 energy :\", MBPT2_fast(bs), \" hartrees\"\n```\n\nAs we will see later, for the infinite electron gas, second-order perturbation theory diverges in the thermodynamical limit, a feature which can easily be noted if one lets the number of single-particle states above the Fermi level to increase. The resulting expression in a Cartesian basis will not converge.\n\n\n\n\n", "meta": {"hexsha": "6eae99d54d3e645f24384bc7998a1998401cb0f5", "size": 130899, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/src/.ipynb_checkpoints/inf-checkpoint.ipynb", "max_stars_repo_name": "NuclearTalent/ManyBody2018", "max_stars_repo_head_hexsha": "2339ed834777fa10f6156344f17494b9a7c0bf91", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2018-07-17T01:09:17.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-08T02:34:02.000Z", "max_issues_repo_path": "doc/src/.ipynb_checkpoints/inf-checkpoint.ipynb", "max_issues_repo_name": "NuclearTalent/ManyBody2018", "max_issues_repo_head_hexsha": "2339ed834777fa10f6156344f17494b9a7c0bf91", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/src/.ipynb_checkpoints/inf-checkpoint.ipynb", "max_forks_repo_name": "NuclearTalent/ManyBody2018", "max_forks_repo_head_hexsha": "2339ed834777fa10f6156344f17494b9a7c0bf91", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2018-07-16T06:31:54.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-01T07:53:38.000Z", "avg_line_length": 47.3928312817, "max_line_length": 29528, "alphanum_fraction": 0.6015324792, "converted": true, "num_tokens": 22161, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.4843800991636031, "lm_q2_score": 0.3073580232098525, "lm_q1q2_score": 0.14887810976111737}}
{"text": "\n\n\n# PHY321: More on Motion and Forces with examples, begin Work and Energy discussion\n**[Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/)**, Department of Physics and Astronomy and Facility for Rare Ion Beams (FRIB), Michigan State University, USA and Department of Physics, University of Oslo, Norway\n\nDate: **Jan 27, 2022**\n\nCopyright 1999-2022, [Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/). Released under CC Attribution-NonCommercial 4.0 license\n\n## Aims and Overarching Motivation\n\n### Monday January 24, Lecture and examples\n\nWe discuss various forces and their pertinent equations of motion\n\nRecommended reading: Taylor 2.1-2.4. Malthe-Sørenssen chapters 6 and 7 contain many interesting examples with codes and solutions.\nWe will cover in particular a falling object in two dimensions with linear air resistance relevant for homework 3.\n\n### Wednesday, Lecture and Examples\n\nWe discuss other force models with examples such as the gravitational\nforce and a spring force. See Malthe-Sørenssen chapter 7.3-7.5.\n\nWe discuss also exercises 5 and 6 from homework 2. We will continue with this on Friday.\n\n### Friday, summary and work on weekly assignments\n\nWe start our discussion of energy and work, see Taylor 4.1 and 4.2 the first 20 minutes. Thereafter we solve exercises.\n\n## Air Resistance in One Dimension\n\nLast week we considered the motion of a falling object with air\nresistance. Here we look at both a quadratic in velocity resistance\nand linear in velocity. But first we give a qualitative argument\nabout the mathematical expression for the air resistance we used last\nFriday. The discussion here is also contained in the [video on how to make a model for a drag force](https://youtu.be/DRTmLZYdTFY).\n\nAir resistance tends to scale as the square of the velocity. This is\nin contrast to many problems chosen for textbooks, where it is linear\nin the velocity. The choice of a linear dependence is motivated by\nmathematical simplicity (it keeps the differential equation linear)\nrather than by physics. One can see that the force should be quadratic\nin velocity by considering the momentum imparted on the air\nmolecules. If an object sweeps through a volume $dV$ of air in time\n$dt$, the momentum imparted on the air is\n\n\n
\n\n$$\n\\begin{equation}\ndP=\\rho_m dV v,\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nwhere $v$ is the velocity of the object and $\\rho_m$ is the mass\ndensity of the air. If the molecules bounce back as opposed to stop\nyou would double the size of the term. The opposite value of the\nmomentum is imparted onto the object itself. Geometrically, the\ndifferential volume is\n\n\n
\n\n$$\n\\begin{equation}\ndV=Avdt,\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nwhere $A$ is the cross-sectional area and $vdt$ is the distance the\nobject moved in time $dt$.\n\n## Resulting Acceleration\nPlugging this into the expression above,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dP}{dt}=-\\rho_m A v^2.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\nThis is the force felt by the particle, and is opposite to its\ndirection of motion. Now, because air doesn't stop when it hits an\nobject, but flows around the best it can, the actual force is reduced\nby a dimensionless factor $c_W$, called the drag coefficient.\n\n\n
\n\n$$\n\\begin{equation}\nF_{\\rm drag}=-c_W\\rho_m Av^2,\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nand the acceleration is\n\n$$\n\\begin{eqnarray}\n\\frac{dv}{dt}=-\\frac{c_W\\rho_mA}{m}v^2.\n\\end{eqnarray}\n$$\n\nFor a particle with initial velocity $v_0$, one can separate the $dt$\nto one side of the equation, and move everything with $v$s to the\nother side. We did this in our discussion of simple motion and will not repeat it here.\n\nOn more general terms,\nfor many systems, e.g. an automobile, there are multiple sources of\nresistance. In addition to wind resistance, where the force is\nproportional to $v^2$, there are dissipative effects of the tires on\nthe pavement, and in the axel and drive train. These other forces can\nhave components that scale proportional to $v$, and components that\nare independent of $v$. Those independent of $v$, e.g. the usual\n$f=\\mu_K N$ frictional force you consider in your first Physics courses, only set in\nonce the object is actually moving. As speeds become higher, the $v^2$\ncomponents begin to dominate relative to the others. For automobiles\nat freeway speeds, the $v^2$ terms are largely responsible for the\nloss of efficiency. To travel a distance $L$ at fixed speed $v$, the\nenergy/work required to overcome the dissipative forces are $fL$,\nwhich for a force of the form $f=\\alpha v^n$ becomes\n\n$$\n\\begin{eqnarray}\nW=\\int dx~f=\\alpha v^n L.\n\\end{eqnarray}\n$$\n\nFor $n=0$ the work is\nindependent of speed, but for the wind resistance, where $n=2$,\nslowing down is essential if one wishes to reduce fuel consumption. It\nis also important to consider that engines are designed to be most\nefficient at a chosen range of power output. Thus, some cars will get\nbetter mileage at higher speeds (They perform better at 50 mph than at\n5 mph) despite the considerations mentioned above.\n\n## Going Ballistic, Projectile Motion or a Softer Approach, Falling Raindrops\n\nAs an example of Newton's Laws we consider projectile motion (or a\nfalling raindrop or a ball we throw up in the air) with a drag force. Even though air resistance is\nlargely proportional to the square of the velocity, we will consider\nthe drag force to be linear to the velocity, $\\boldsymbol{F}=-m\\gamma\\boldsymbol{v}$,\nfor the purposes of this exercise.\n\nSuch a dependence can be extracted from experimental data for objects moving at low velocities, see for example Malthe-Sørenssen chapter 5.6.\n\nWe will here focus on a two-dimensional problem.\n\n## Two-dimensional falling object\n\nThe acceleration for a projectile moving upwards,\n$\\boldsymbol{a}=\\boldsymbol{F}/m$, becomes\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{dt}=-\\gamma v_x,\\\\\n\\nonumber\n\\frac{dv_y}{dt}=-\\gamma v_y-g,\n\\end{eqnarray}\n$$\n\nand $\\gamma$ has dimensions of inverse time. \n\nIf you on the other hand have a falling raindrop, how do these equations change? See for example Figure 2.1 in Taylor.\nLet us stay with a ball which is thrown up in the air at $t=0$.\n\n## Ways of solving these equations\n\nWe will go over two different ways to solve this equation. The first\nby direct integration, and the second as a differential equation. To\ndo this by direct integration, one simply multiplies both sides of the\nequations above by $dt$, then divide by the appropriate factors so\nthat the $v$s are all on one side of the equation and the $dt$ is on\nthe other. For the $x$ motion one finds an easily integrable equation,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{v_x}&=&-\\gamma dt,\\\\\n\\nonumber\n\\int_{v_{0x}}^{v_{x}}\\frac{dv_x}{v_x}&=&-\\gamma\\int_0^{t}dt,\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{x}}{v_{0x}}\\right)&=&-\\gamma t,\\\\\n\\nonumber\nv_{x}(t)&=&v_{0x}e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nThis is very much the result you would have written down\nby inspection. For the $y$-component of the velocity,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_y}{v_y+g/\\gamma}&=&-\\gamma dt\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{y}+g/\\gamma}{v_{0y}-g/\\gamma}\\right)&=&-\\gamma t_f,\\\\\n\\nonumber\nv_{fy}&=&-\\frac{g}{\\gamma}+\\left(v_{0y}+\\frac{g}{\\gamma}\\right)e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nWhereas $v_x$ starts at some value and decays\nexponentially to zero, $v_y$ decays exponentially to the terminal\nvelocity, $v_t=-g/\\gamma$.\n\n## Solving as differential equations\n\nAlthough this direct integration is simpler than the method we invoke\nbelow, the method below will come in useful for some slightly more\ndifficult differential equations in the future. The differential\nequation for $v_x$ is straight-forward to solve. Because it is a first\norder differential euqation there is one arbitrary constant, $A$, and by inspection the\nsolution is\n\n\n
\n\n$$\n\\begin{equation}\nv_x=Ae^{-\\gamma t}.\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\nThe arbitrary constants for equations of motion are usually determined\nby the initial conditions, or more generally boundary conditions. By\ninspection $A=v_{0x}$, the initial $x$ component of the velocity.\n\n## Differential Equations, contn\nThe differential equation for $v_y$ is a bit more complicated due to\nthe presence of $g$. Differential equations where all the terms are\nlinearly proportional to a function, in this case $v_y$, or to\nderivatives of the function, e.g., $v_y$, $dv_y/dt$,\n$d^2v_y/dt^2\\cdots$, are called linear differential equations. If\nthere are terms proportional to $v^2$, as would happen if the drag\nforces were proportional to the square of the velocity, the\ndifferential equation is not longer linear. Because this expression\nhas only one derivative in $v$ it is a first-order linear differential\nequation. If a term were added proportional to $d^2v/dt^2$ it would be\na second-order differential equation. In this case we have a term\ncompletely independent of $v$, the gravitational acceleration $g$, and\nthe usual strategy is to first rewrite the equation with all the\nlinear terms on one side of the equal sign,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_y}{dt}+\\gamma v_y=-g.\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\n## Splitting into two parts\n\nNow, the solution to the equation can be broken into two\nparts. Because this is a first-order differential equation we know\nthat there will be one arbitrary constant. Physically, the arbitrary\nconstant will be determined by setting the initial velocity, though it\ncould be determined by setting the velocity at any given time. Like\nmost differential equations, solutions are not \"solved\". Instead,\none guesses at a form, then shows the guess is correct. For these\ntypes of equations, one first tries to find a single solution,\ni.e. one with no arbitrary constants. This is called the {\\it\nparticular} solution, $y_p(t)$, though it should really be called\n\"a\" particular solution because there are an infinite number of such\nsolutions. One then finds a solution to the {\\it homogenous} equation,\nwhich is the equation with zero on the right-hand side,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,h}}{dt}+\\gamma v_{y,h}=0.\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nHomogenous solutions will have arbitrary constants. \n\nThe particular solution will solve the same equation as the original\ngeneral equation\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,p}}{dt}+\\gamma v_{y,p}=-g.\n\\label{_auto8} \\tag{8}\n\\end{equation}\n$$\n\nHowever, we don't need find one with arbitrary constants. Hence, it is\ncalled a **particular** solution.\n\nThe sum of the two,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=v_{y,p}+v_{y,h},\n\\label{_auto9} \\tag{9}\n\\end{equation}\n$$\n\nis a solution of the total equation because of the linear nature of\nthe differential equation. One has now found a *general* solution\nencompassing all solutions, because it both satisfies the general\nequation (like the particular solution), and has an arbitrary constant\nthat can be adjusted to fit any initial condition (like the homogeneous\nsolution). If the equations were not linear, that is if there were terms\nsuch as $v_y^2$ or $v_y\\dot{v}_y$, this technique would not work.\n\n## More details\n\nReturning to the example above, the homogenous solution is the same as\nthat for $v_x$, because there was no gravitational acceleration in\nthat case,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,h}=Be^{-\\gamma t}.\n\\label{_auto10} \\tag{10}\n\\end{equation}\n$$\n\nIn this case a particular solution is one with constant velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,p}=-g/\\gamma.\n\\label{_auto11} \\tag{11}\n\\end{equation}\n$$\n\nNote that this is the terminal velocity of a particle falling from a\ngreat height. The general solution is thus,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=Be^{-\\gamma t}-g/\\gamma,\n\\label{_auto12} \\tag{12}\n\\end{equation}\n$$\n\nand one can find $B$ from the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{0y}=B-g/\\gamma,~~~B=v_{0y}+g/\\gamma.\n\\label{_auto13} \\tag{13}\n\\end{equation}\n$$\n\nPlugging in the expression for $B$ gives the $y$ motion given the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=(v_{0y}+g/\\gamma)e^{-\\gamma t}-g/\\gamma.\n\\label{_auto14} \\tag{14}\n\\end{equation}\n$$\n\nIt is easy to see that this solution has $v_y=v_{0y}$ when $t=0$ and\n$v_y=-g/\\gamma$ when $t\\rightarrow\\infty$.\n\nOne can also integrate the two equations to find the coordinates $x$\nand $y$ as functions of $t$,\n\n$$\n\\begin{eqnarray}\nx&=&\\int_0^t dt'~v_{0x}(t')=\\frac{v_{0x}}{\\gamma}\\left(1-e^{-\\gamma t}\\right),\\\\\n\\nonumber\ny&=&\\int_0^t dt'~v_{0y}(t')=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\end{eqnarray}\n$$\n\nIf the question was to find the position at a time $t$, we would be\nfinished. However, the more common goal in a projectile equation\nproblem is to find the range, i.e. the distance $x$ at which $y$\nreturns to zero. For the case without a drag force this was much\nsimpler. The solution for the $y$ coordinate would have been\n$y=v_{0y}t-gt^2/2$. One would solve for $t$ to make $y=0$, which would\nbe $t=2v_{0y}/g$, then plug that value for $t$ into $x=v_{0x}t$ to\nfind $x=2v_{0x}v_{0y}/g=v_0\\sin(2\\theta_0)/g$. One follows the same\nsteps here, except that the expression for $y(t)$ is more\ncomplicated. Searching for the time where $y=0$, and we get\n\n\n
\n\n$$\n\\begin{equation}\n0=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\label{_auto15} \\tag{15}\n\\end{equation}\n$$\n\nThis cannot be inverted into a simple expression $t=\\cdots$. Such\nexpressions are known as \"transcendental equations\", and are not the\nrare instance, but are the norm. In the days before computers, one\nmight plot the right-hand side of the above graphically as\na function of time, then find the point where it crosses zero.\n\nNow, the most common way to solve for an equation of the above type\nwould be to apply Newton's method numerically. This involves the\nfollowing algorithm for finding solutions of some equation $F(t)=0$.\n\n1. First guess a value for the time, $t_{\\rm guess}$.\n\n2. Calculate $F$ and its derivative, $F(t_{\\rm guess})$ and $F'(t_{\\rm guess})$. \n\n3. Unless you guessed perfectly, $F\\ne 0$, and assuming that $\\Delta F\\approx F'\\Delta t$, one would choose \n\n4. $\\Delta t=-F(t_{\\rm guess})/F'(t_{\\rm guess})$.\n\n5. Now repeat step 1, but with $t_{\\rm guess}\\rightarrow t_{\\rm guess}+\\Delta t$.\n\nIf the $F(t)$ were perfectly linear in $t$, one would find $t$ in one\nstep. Instead, one typically finds a value of $t$ that is closer to\nthe final answer than $t_{\\rm guess}$. One breaks the loop once one\nfinds $F$ within some acceptable tolerance of zero. A program to do\nthis will be added shortly.\n\n## Motion in a Magnetic Field\n\nThis case is just another example of motion under a specific force.\n\nAnother example of a velocity-dependent force is magnetism,\n\n$$\n\\begin{eqnarray}\n\\boldsymbol{F}&=&q\\boldsymbol{v}\\times\\boldsymbol{B},\\\\\n\\nonumber\nF_i&=&q\\sum_{jk}\\epsilon_{ijk}v_jB_k.\n\\end{eqnarray}\n$$\n\nFor a uniform field in the $z$ direction $\\boldsymbol{B}=B\\hat{z}$, the force can only have $x$ and $y$ components,\n\n$$\n\\begin{eqnarray}\nF_x&=&qBv_y\\\\\n\\nonumber\nF_y&=&-qBv_x.\n\\end{eqnarray}\n$$\n\nThe differential equations are\n\n$$\n\\begin{eqnarray}\n\\dot{v}_x&=&\\omega_c v_y,\\omega_c= qB/m\\\\\n\\nonumber\n\\dot{v}_y&=&-\\omega_c v_x.\n\\end{eqnarray}\n$$\n\nOne can solve the equations by taking time derivatives of either equation, then substituting into the other equation,\n\n$$\n\\begin{eqnarray}\n\\ddot{v}_x=\\omega_c\\dot{v_y}=-\\omega_c^2v_x,\\\\\n\\nonumber\n\\ddot{v}_y&=&-\\omega_c\\dot{v}_x=-\\omega_cv_y.\n\\end{eqnarray}\n$$\n\nThe solution to these equations can be seen by inspection,\n\n$$\n\\begin{eqnarray}\nv_x&=&A\\sin(\\omega_ct+\\phi),\\\\\n\\nonumber\nv_y&=&A\\cos(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nOne can integrate the equations to find the positions as a function of time,\n\n$$\n\\begin{eqnarray}\nx-x_0&=&\\int_{x_0}^x dx=\\int_0^t dt v(t)\\\\\n\\nonumber\n&=&\\frac{-A}{\\omega_c}\\cos(\\omega_ct+\\phi),\\\\\n\\nonumber\ny-y_0&=&\\frac{A}{\\omega_c}\\sin(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nThe trajectory is a circle centered at $x_0,y_0$ with amplitude $A$ rotating in the clockwise direction.\n\nThe equations of motion for the $z$ motion are\n\n\n
\n\n$$\n\\begin{equation}\n\\dot{v_z}=0,\n\\label{_auto16} \\tag{16}\n\\end{equation}\n$$\n\nwhich leads to\n\n\n
\n\n$$\n\\begin{equation}\nz-z_0=V_zt.\n\\label{_auto17} \\tag{17}\n\\end{equation}\n$$\n\nAdded onto the circle, the motion is helical.\n\nNote that the kinetic energy,\n\n\n
\n\n$$\n\\begin{equation}\nT=\\frac{1}{2}m(v_x^2+v_y^2+v_z^2)=\\frac{1}{2}m(\\omega_c^2A^2+V_z^2),\n\\label{_auto18} \\tag{18}\n\\end{equation}\n$$\n\nis constant. This is because the force is perpendicular to the\nvelocity, so that in any differential time element $dt$ the work done\non the particle $\\boldsymbol{F}\\cdot{dr}=dt\\boldsymbol{F}\\cdot{v}=0$.\n\nOne should think about the implications of a velocity dependent\nforce. Suppose one had a constant magnetic field in deep space. If a\nparticle came through with velocity $v_0$, it would undergo cyclotron\nmotion with radius $R=v_0/\\omega_c$. However, if it were still its\nmotion would remain fixed. Now, suppose an observer looked at the\nparticle in one reference frame where the particle was moving, then\nchanged their velocity so that the particle's velocity appeared to be\nzero. The motion would change from circular to fixed. Is this\npossible?\n\nThe solution to the puzzle above relies on understanding\nrelativity. Imagine that the first observer believes $\\boldsymbol{B}\\ne 0$ and\nthat the electric field $\\boldsymbol{E}=0$. If the observer then changes\nreference frames by accelerating to a velocity $\\boldsymbol{v}$, in the new\nframe $\\boldsymbol{B}$ and $\\boldsymbol{E}$ both change. If the observer moved to the\nframe where the charge, originally moving with a small velocity $v$,\nis now at rest, the new electric field is indeed $\\boldsymbol{v}\\times\\boldsymbol{B}$,\nwhich then leads to the same acceleration as one had before. If the\nvelocity is not small compared to the speed of light, additional\n$\\gamma$ factors come into play,\n$\\gamma=1/\\sqrt{1-(v/c)^2}$. Relativistic motion will not be\nconsidered in this course.\n\n## Sliding Block tied to a Wall\n\nAnother classical case is that of simple harmonic oscillations, here\nrepresented by a block sliding on a horizontal frictionless\nsurface. The block is tied to a wall with a spring. If the spring is\nnot compressed or stretched too far, the force on the block at a given\nposition $x$ is\n\n$$\nF=-kx.\n$$\n\n## Back and Forth, Sliding Block with no friction\n\nThe negative sign means that the force acts to restore the object to an equilibrium position. Newton's equation of motion for this idealized system is then\n\n$$\nm\\frac{d^2x}{dt^2}=-kx,\n$$\n\nor we could rephrase it as\n\n\n
\n\n$$\n\\frac{d^2x}{dt^2}=-\\frac{k}{m}x=-\\omega_0^2x,\n\\label{eq:newton1} \\tag{19}\n$$\n\nwith the angular frequency $\\omega_0^2=k/m$. \n\nWe will derive the above force when we start studying **harmonic oscillations**.\n\n## Final rewrite\n\nWith the position $x(t)$ and the velocity $v(t)=dx/dt$ we can reformulate Newton's equation in the following way\n\n$$\n\\frac{dx(t)}{dt}=v(t),\n$$\n\nand\n\n$$\n\\frac{dv(t)}{dt}=-\\omega_0^2x(t).\n$$\n\nWith initial conditions $x(t_0)=x_0$ and $v(t_0)=v_0$ we can in turn solve the differential equations.\n\n## Analytical Solution\n\nThe above differential equation has the advantage that it can be\nsolved analytically with general solutions on the form\n\n$$\nx(t)=A\\cos{\\omega_0t}+B\\sin{\\omega_0t},\n$$\n\nand\n\n$$\nv(t)=-\\omega_0 A\\sin{\\omega_0t}+\\omega_0 B\\cos{\\omega_0t},\n$$\n\nwhere $A$ and $B$ are constants to be determined from the initial conditions.\n\nThis provides in turn an important test for the numerical solution and\nthe development of a program for more complicated cases which cannot\nbe solved analytically.\n\nWe will discuss the above equations in more detail when we discuss harmonic oscillations.\n\n## Summarizing the various motion problems 1\n\nThe examples we have discussed above were included in order to\nillustrate various methods (which depend on the specific problem) to\nfind the solutions of the equations of motion.\nWe have solved the equations of motion in the following ways:\n\n**Solve the differential equations analytically.**\n\nWe did this for example with the following object in one or two dimensions or the sliding block. \nHere we had for example an equation set like\n\n$$\n\\frac{dv_x}{dt}=-\\gamma v_x,\n$$\n\nand\n\n$$\n\\frac{dv_y}{dt}=-\\gamma v_y-g,\n$$\n\nand $\\gamma$ has dimension of inverse time.\n\n## Summarizing the various motion problems 2\n\n**Integrate the equations.**\n\nWe could also integrate directly in case we can separate the degrees of freedom in a an easy way. Take for example one of the equations in the previous slide\n\n$$\n\\frac{dv_x}{dt}=-\\gamma v_x,\n$$\n\nwhich we can rewrite in terms of a left-hand side which depends only on the velocity and a right-hand side which depends only on time\n\n$$\n\\frac{dv_x}{v_x}=-\\gamma dt.\n$$\n\nIntegrating we have (since we can separate $v_x$ and $t$)\n\n$$\n\\int_{v_0}^{v_t}\\frac{dv_x}{v_x}=-\\int_{t_0}^{t_f}\\gamma dt,\n$$\n\nwhere $v_f$ is the velocity at a final time and $t_f$ is the final time.\nIn this case we found, after having integrated the above two sides that\n\n$$\nv_f(t)=v_0\\exp{-\\gamma t}.\n$$\n\n## Summarizing the various motion problems 3\n\n**Solve the differential equations numerically.**\n\nFinally, using for example Euler's method, we can solve the\ndifferential equations numerically. If we can compare our numerical\nsolutions with analytical solutions, we have an extra check of our\nnumerical approaches.\n\nThe example code on the next slide is relevant for homework 3. Here we deal with a falling object in two dimensions. Except for the derivations above with an\nair resistance which is linear in the velocity, homework 3 uses a quadratic velocity dependence.\n\n## Code example using Euler's methods\n\n**Note**: this code needs some additional expressions and will not run\n\n\n```\n%matplotlib inline\n\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\n#define the gravitational acceleration\ng = 9.80655 #m/s^2\n# The mass and the drag constant D\nD = 0.00245 #mass/length kg/m\nm = 0.2 #kg, mass of falling object\nDeltaT = 0.001\n#set up final time, here just a number we have chosen\ntfinal = 1.0\n# set up number of points for all variables\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and y and arrays for analytical results\n# Note the brute force setting up of arrays for x and y, vx, vy, ax and ay\n# For hw3 you should think of using the 2-dim vectors you used in homework 2\nt = np.zeros(n)\nvy = np.zeros(n)\ny = np.zeros(n)\nvx = np.zeros(n)\nx = np.zeros(n)\n# Initial conditions\nvx[0] = 10.0 #m/s\nvy[0] = 0.0 #m/s\ny[0] = 10.0 #m\nx[0] = 0.0 #m\n# Start integrating using Euler's method\nfor i in range(n-1):\n # expression for acceleration, note the absolute value and division by mass\n# ax = You need to set up the expression for force and thereby the acceleration in the x-direction\n# ay = You need to set up the expression for force and thereby the acceleration in the y-direction\n # update velocity and position\n vx[i+1] = vx[i] + DeltaT*ax\n x[i+1] = x[i] + DeltaT*vx[i]\n vy[i+1] = vy[i] + DeltaT*ay\n y[i+1] = y[i] + DeltaT*vy[i]\n # update time to next time step and compute analytical answer\n t[i+1] = t[i] + DeltaT\n# Here you need to set up the analytical solution for y(t) and x(t)\n\nif ( y[i+1] < 0.0):\n break\ndata = {'t[s]': t,\n 'Relative error in y': abs((y-yanalytic)/yanalytic),\n 'vy[m/s]': vy,\n 'Relative error in x': abs((x-xanalytic)/xanalytic),\n 'vx[m/s]': vx\n}\nNewData = pd.DataFrame(data)\ndisplay(NewData)\n# save to file\nNewData.to_csv(outfile, index=False)\n#then plot\nfig, axs = plt.subplots(4, 1)\naxs[0].plot(t, y)\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y')\naxs[1].plot(t, vy)\naxs[1].set_ylabel('vy[m/s]')\naxs[1].set_xlabel('time[s]')\naxs[2].plot(t, x)\naxs[2].set_xlim(0, tfinal)\naxs[2].set_ylabel('x')\naxs[3].plot(t, vx)\naxs[3].set_ylabel('vx[m/s]')\naxs[3].set_xlabel('time[s]')\nfig.tight_layout()\nplt.show()\n```\n\n## Work, Energy, Momentum and Conservation laws\n\nThe previous three cases have shown us how to use Newton’s laws of\nmotion to determine the motion of an object based on the forces acting\non it. For two of the cases there is an underlying assumption that we can find an analytical solution to a continuous problem.\nWith a continuous problem we mean a problem where the various variables can take any value within a finite or infinite interval. \n\nUnfortunately, in many cases we\ncannot find an exact solution to the equations of motion we get from\nNewton’s second law. The numerical approach, where we discretize the continuous problem, allows us however to study a much richer set of problems.\nFor problems involving Newton's laws and the various equations of motion we encounter, solving the equations numerically, is the standard approach.\n\nIt allows us to focus on the underlying forces. Often we end up using the same numerical algorithm for different problems.\n\nHere we introduce a commonly used technique that allows us to find the\nvelocity as a function of position without finding the position as a\nfunction of time—an alternate form of Newton’s second law. The method\nis based on a simple principle: Instead of solving the equations of\nmotion directly, we integrate the equations of motion. Such a method\nis called an integration method. \n\nThis allows us also to introduce the **work-energy** theorem. This\ntheorem lets us find the velocity as a function of position for\nan object even in cases when we cannot solve the equations of\nmotion. This introduces us to the concept of work and kinetic energy,\nwhich is the energy related to the motion of an object.\n\nAnd finally, later, we will link the work-energy theorem with the principle of conservation of energy.\n\n## The Work-Energy Theorem\n\nLet us define the kinetic energy $K$ with a given velocity $\\boldsymbol{v}$\n\n$$\nK=\\frac{1}{2}mv^2,\n$$\n\nwhere $m$ is the mass of the object we are considering.\nWe assume also that there is a force $\\boldsymbol{F}$ acting on the given object\n\n$$\n\\boldsymbol{F}=\\boldsymbol{F}(\\boldsymbol{r},\\boldsymbol{v},t),\n$$\n\nwith $\\boldsymbol{r}$ the position and $t$ the time.\nIn general we assume the force is a function of all these variables.\nMany of the more central forces in Nature however, depende only on the\nposition. Examples are the gravitational force and the force derived\nfrom the Coulomb potential in electromagnetism.\n\n## Rewriting the Kinetic Energy\n\nLet us study the derivative of the kinetic energy with respect to time $t$. Its continuous form is\n\n$$\n\\frac{dK}{dt}=\\frac{1}{2}m\\frac{d\\boldsymbol{v}\\cdot\\boldsymbol{v}}{dt}.\n$$\n\nUsing our results from exercise 3 of homework 1, we can write the derivative of a vector dot product as\n\n$$\n\\frac{dK}{dt}=\\frac{1}{2}m\\frac{d\\boldsymbol{v}\\cdot\\boldsymbol{v}}{dt}= \\frac{1}{2}m\\left(\\frac{d\\boldsymbol{v}}{dt}\\cdot\\boldsymbol{v}+\\boldsymbol{v}\\cdot\\frac{d\\boldsymbol{v}}{dt}\\right)=m\\frac{d\\boldsymbol{v}}{dt}\\cdot\\boldsymbol{v}.\n$$\n\nWe know also that the acceleration is defined as\n\n$$\n\\boldsymbol{a}=\\frac{\\boldsymbol{F}}{m}=\\frac{d\\boldsymbol{v}}{dt}.\n$$\n\nWe can then rewrite the equation for the derivative of the kinetic energy as\n\n$$\n\\frac{dK}{dt}=m\\frac{d\\boldsymbol{v}}{dt}\\boldsymbol{v}=\\boldsymbol{F}\\frac{d\\boldsymbol{r}}{dt},\n$$\n\nwhere we defined the velocity as the derivative of the position with respect to time.\n\n## Discretizing\n\nLet us now discretize the above equation by letting the instantaneous terms be replaced by a discrete quantity, that is\nwe let $dK\\rightarrow \\Delta K$, $dt\\rightarrow \\Delta t$, $d\\boldsymbol{r}\\rightarrow \\Delta \\boldsymbol{r}$ and $d\\boldsymbol{v}\\rightarrow \\Delta \\boldsymbol{v}$.\n\nWe have then\n\n$$\n\\frac{\\Delta K}{\\Delta t}=m\\frac{\\Delta \\boldsymbol{v}}{\\Delta t}\\boldsymbol{v}=\\boldsymbol{F}\\frac{\\Delta \\boldsymbol{r}}{\\Delta t},\n$$\n\nor by multiplying out $\\Delta t$ we have\n\n$$\n\\Delta K=\\boldsymbol{F}\\Delta \\boldsymbol{r}.\n$$\n\nWe define this quantity as the **work** done by the force $\\boldsymbol{F}$\nduring the displacement $\\Delta \\boldsymbol{r}$. If we study the dimensionality\nof this problem we have mass times length squared divided by time\nsquared, or just dimension energy.\n\n## Difference in kinetic energy\n\nIf we now define a series of such displacements $\\Delta\\boldsymbol{r}$ we have a difference in kinetic energy at a final position $\\boldsymbol{r}_n$ and an \ninitial position $\\boldsymbol{r}_0$ given by\n\n$$\n\\Delta K=\\frac{1}{2}mv_n^2-\\frac{1}{2}mv_0^2=\\sum_{i=0}^n\\boldsymbol{F}_i\\Delta \\boldsymbol{r},\n$$\n\nwhere $\\boldsymbol{F}_i$ are the forces acting at every position $\\boldsymbol{r}_i$.\n\nThe work done by acting with a force on a set of displacements can\nthen be as expressed as the difference between the initial and final\nkinetic energies.\n\nThis defines the **work-energy** theorem.\n\n## From the discrete version to the continuous version\n\nIf we take the limit $\\Delta \\boldsymbol{r}\\rightarrow 0$, we can rewrite the sum over the various displacements in terms of an integral, that is\n\n$$\n\\Delta K=\\frac{1}{2}mv_n^2-\\frac{1}{2}mv_0^2=\\sum_{i=0}^n\\boldsymbol{F}_i\\Delta \\boldsymbol{r}\\rightarrow \\int_{\\boldsymbol{r}_0}^{\\boldsymbol{r}_n}\\boldsymbol{F}(\\boldsymbol{r},\\boldsymbol{v},t)d\\boldsymbol{r}.\n$$\n\nThis integral defines a path integral since it will depend on the given path we take between the two end points. We will replace the limits with the symbol $c$ in order to indicate that we take a specific countour in space when the force acts on the system. That is the work $W_{n0}$ between two points $\\boldsymbol{r}_n$ and $\\boldsymbol{r}_0$ is labeled as\n\n$$\nW_{n0}=\\frac{1}{2}mv_n^2-\\frac{1}{2}mv_0^2=\\int_{c}\\boldsymbol{F}(\\boldsymbol{r},\\boldsymbol{v},t)d\\boldsymbol{r}.\n$$\n\nNote that if the force is perpendicular to the displacement, then the force does not affect the kinetic energy.\n\nLet us now study some examples of forces and how to find the velocity from the integration over a given path.\n\nThereafter we study how to evaluate an integral numerically.\n\n## Studying the Work-energy Theorem numerically\n\nIn order to study the work- energy, we will normally need to perform\na numerical integration, unless we can integrate analytically. Here we\npresent some of the simpler methods such as the **rectangle** rule, the **trapezoidal** rule and higher-order methods like the Simpson family of methods.\n\n## Example of an Electron moving along a Surface\n\nAs an example, let us consider the following case.\nWe have classical electron which moves in the $x$-direction along a surface. The force from the surface is\n\n$$\n\\boldsymbol{F}(x)=-F_0\\sin{(\\frac{2\\pi x}{b})}\\boldsymbol{e}_1.\n$$\n\nThe constant $b$ represents the distance between atoms at the surface of the material, $F_0$ is a constant and $x$ is the position of the electron.\n\nUsing the work-energy theorem we can find the work $W$ done when moving an electron from a position $x_0$ to a final position $x$ through the\n integral\n\n$$\nW=\\int_{x_0}^x \\boldsymbol{F}(x')dx' = -\\int_{x_0}^x F_0\\sin{(\\frac{2\\pi x'}{b})} dx',\n$$\n\nwhich results in\n\n$$\nW=\\frac{F_0b}{2\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-\\cos{(\\frac{2\\pi x_0}{b})}\\right].\n$$\n\n## Finding the Velocity\n\nIf we now use the work-energy theorem we can find the the velocity at a final position $x$ by setting up\nthe differences in kinetic energies between the final position and the initial position $x_0$.\n\nWe have that the work done by the force is given by the difference in kinetic energies as\n\n$$\nW=\\frac{1}{2}m\\left(v^2(x)-v^2(x_0)\\right)=\\frac{F_0b}{2\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-\\cos{(\\frac{2\\pi x_0}{b})}\\right],\n$$\n\nand labeling $v(x_0)=v_0$ (and assuming we know the initial velocity) we have\n\n$$\nv(x)=\\pm \\sqrt{v_0^2+\\frac{F_0b}{m\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-\\cos{(\\frac{2\\pi x_0}{b})}\\right]},\n$$\n\nChoosing $x_0=0$m and $v_0=0$m/s we can simplify the above equation to\n\n$$\nv(x)=\\pm \\sqrt{\\frac{F_0b}{m\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-1\\right]},\n$$\n\n## Harmonic Oscillations\n\nAnother well-known force (and we will derive when we come to Harmonic\nOscillations) is the case of a sliding block attached to a wall\nthrough a spring. The block is attached to a spring with spring\nconstant $k$. The other end of the spring is attached to the wall at\nthe origin $x=0$. We assume the spring has an equilibrium length\n$L_0$.\n\nThe force $F_x$ from the spring on the block is then\n\n$$\nF_x=-k(x-L_0).\n$$\n\nThe position $x$ where the spring force is zero is called the equilibrium position. In our case this is\n$x=L_0$.\n\nWe can now compute the work done by this force when we move our block from an initial position $x_0$ to a final position $x$\n\n$$\nW=\\int_{x_0}^{x}F_xdx'=-k\\int_{x_0}^{x}(x'-L_0)dx'=\\frac{1}{2}k(x_0-L_0)^2-\\frac{1}{2}k(x-L_0)^2.\n$$\n\nIf we now bring back the definition of the work-energy theorem in terms of the kinetic energy we have\n\n$$\nW=\\frac{1}{2}mv^2(x)-\\frac{1}{2}mv_0^2=\\frac{1}{2}k(x_0-L_0)^2-\\frac{1}{2}k(x-L_0)^2,\n$$\n\nwhich we rewrite as\n\n$$\n\\frac{1}{2}mv^2(x)+\\frac{1}{2}k(x-L_0)^2=\\frac{1}{2}mv_0^2+\\frac{1}{2}k(x_0-L_0)^2.\n$$\n\nWhat does this mean? The total energy, which is the sum of potential and kinetic energy, is conserved.\nWow, this sounds interesting. We will analyze this next week in more detail when we study energy, momentum and angular momentum conservation.\n\n## Numerical Integration\n\nThis material is optional. We will not cover this in the lectures and we will not use it in exercises or exams.\nIt is included here for the same of completeness.\n\nLet us now see how we could have solved the above integral numerically.\n\nThere are several numerical algorithms for finding an integral\nnumerically. The more familiar ones like the rectangular rule or the\ntrapezoidal rule have simple geometric interpretations.\n\nLet us look at the mathematical details of what are called equal-step methods, also known as Newton-Cotes quadrature.\n\n## Newton-Cotes Quadrature or equal-step methods\nThe integral\n\n\n
\n\n$$\n\\begin{equation}\n I=\\int_a^bf(x) dx\n\\label{eq:integraldef} \\tag{20}\n\\end{equation}\n$$\n\nhas a very simple meaning. The integral is the\narea enscribed by the function $f(x)$ starting from $x=a$ to $x=b$. It is subdivided in several smaller areas whose evaluation is to be approximated by different techniques. The areas under the curve can for example be approximated by rectangular boxes or trapezoids.\n\n## Basic philosophy of equal-step methods\nIn considering equal step methods, our basic approach is that of approximating\na function $f(x)$ with a polynomial of at most \ndegree $N-1$, given $N$ integration points. If our polynomial is of degree $1$,\nthe function will be approximated with $f(x)\\approx a_0+a_1x$.\n\n## Simple algorithm for equal step methods\nThe algorithm for these integration methods is rather simple, and the number of approximations perhaps unlimited!\n\n* Choose a step size $h=(b-a)/N$ where $N$ is the number of steps and $a$ and $b$ the lower and upper limits of integration.\n\n* With a given step length we rewrite the integral as\n\n$$\n\\int_a^bf(x) dx= \\int_a^{a+h}f(x)dx + \\int_{a+h}^{a+2h}f(x)dx+\\dots \\int_{b-h}^{b}f(x)dx.\n$$\n\n* The strategy then is to find a reliable polynomial approximation for $f(x)$ in the various intervals. Choosing a given approximation for $f(x)$, we obtain a specific approximation to the integral.\n\n* With this approximation to $f(x)$ we perform the integration by computing the integrals over all subintervals.\n\n## Simple algorithm for equal step methods\n\nOne possible strategy then is to find a reliable polynomial expansion for $f(x)$ in the smaller\nsubintervals. Consider for example evaluating\n\n$$\n\\int_a^{a+2h}f(x)dx,\n$$\n\nwhich we rewrite as\n\n\n
\n\n$$\n\\begin{equation}\n\\int_a^{a+2h}f(x)dx=\\int_{x_0-h}^{x_0+h}f(x)dx.\n\\label{eq:hhint} \\tag{21}\n\\end{equation}\n$$\n\nWe have chosen a midpoint $x_0$ and have defined $x_0=a+h$.\n\n## The rectangle method\n\nA very simple approach is the so-called midpoint or rectangle method.\nIn this case the integration area is split in a given number of rectangles with length $h$ and height given by the mid-point value of the function. This gives the following simple rule for approximating an integral\n\n\n
\n\n$$\n\\begin{equation}\nI=\\int_a^bf(x) dx \\approx h\\sum_{i=1}^N f(x_{i-1/2}), \n\\label{eq:rectangle} \\tag{22}\n\\end{equation}\n$$\n\nwhere $f(x_{i-1/2})$ is the midpoint value of $f$ for a given rectangle. We will discuss its truncation \nerror below. It is easy to implement this algorithm, as shown below\n\n## Truncation error for the rectangular rule\n\nThe correct mathematical expression for the local error for the rectangular rule $R_i(h)$ for element $i$ is\n\n$$\n\\int_{-h}^hf(x)dx - R_i(h)=-\\frac{h^3}{24}f^{(2)}(\\xi),\n$$\n\nand the global error reads\n\n$$\n\\int_a^bf(x)dx -R_h(f)=-\\frac{b-a}{24}h^2f^{(2)}(\\xi),\n$$\n\nwhere $R_h$ is the result obtained with rectangular rule and $\\xi \\in [a,b]$.\n\n## Codes for the Rectangular rule\n\nWe go back to our simple example above and set $F_0=b=1$ and choose $x_0=0$ and $x=1/2$, and have\n\n$$\nW=\\frac{1}{\\pi}.\n$$\n\nThe code here computes the integral using the rectangle rule and $n=100$ integration points we have a relative error of\n$10^{-5}$.\n\n\n```\nfrom math import sin, pi\nimport numpy as np\nfrom sympy import Symbol, integrate\n# function for the Rectangular rule \ndef Rectangular(a,b,f,n):\n h = (b-a)/float(n)\n s = 0\n for i in range(0,n,1):\n x = (i+0.5)*h\n s = s+ f(x)\n return h*s\n# function to integrate\ndef function(x):\n return sin(2*pi*x)\n# define integration limits and integration points \na = 0.0; b = 0.5;\nn = 100\nExact = 1./pi\nprint(\"Relative error= \", abs( (Rectangular(a,b,function,n)-Exact)/Exact))\n```\n\n## The trapezoidal rule\n\nThe other integral gives\n\n$$\n\\int_{x_0-h}^{x_0}f(x)dx=\\frac{h}{2}\\left(f(x_0) + f(x_0-h)\\right)+O(h^3),\n$$\n\nand adding up we obtain\n\n\n
\n\n$$\n\\begin{equation}\n \\int_{x_0-h}^{x_0+h}f(x)dx=\\frac{h}{2}\\left(f(x_0+h) + 2f(x_0) + f(x_0-h)\\right)+O(h^3),\n\\label{eq:trapez} \\tag{23}\n\\end{equation}\n$$\n\nwhich is the well-known trapezoidal rule. Concerning the error in the approximation made,\n$O(h^3)=O((b-a)^3/N^3)$, you should note \nthat this is the local error. Since we are splitting the integral from\n$a$ to $b$ in $N$ pieces, we will have to perform approximately $N$ \nsuch operations.\n\nThis means that the *global error* goes like $\\approx O(h^2)$. \nThe trapezoidal reads then\n\n\n
\n\n$$\n\\begin{equation}\n I=\\int_a^bf(x) dx=h\\left(f(a)/2 + f(a+h) +f(a+2h)+\n \\dots +f(b-h)+ f_{b}/2\\right),\n\\label{eq:trapez1} \\tag{24}\n\\end{equation}\n$$\n\nwith a global error which goes like $O(h^2)$. \n\nHereafter we use the shorthand notations $f_{-h}=f(x_0-h)$, $f_{0}=f(x_0)$\nand $f_{h}=f(x_0+h)$.\n\n## Error in the trapezoidal rule\n\nThe correct mathematical expression for the local error for the trapezoidal rule is\n\n$$\n\\int_a^bf(x)dx -\\frac{b-a}{2}\\left[f(a)+f(b)\\right]=-\\frac{h^3}{12}f^{(2)}(\\xi),\n$$\n\nand the global error reads\n\n$$\n\\int_a^bf(x)dx -T_h(f)=-\\frac{b-a}{12}h^2f^{(2)}(\\xi),\n$$\n\nwhere $T_h$ is the trapezoidal result and $\\xi \\in [a,b]$.\n\n## Algorithm for the trapezoidal rule\nThe trapezoidal rule is easy to implement numerically \nthrough the following simple algorithm\n\n * Choose the number of mesh points and fix the step length.\n\n * calculate $f(a)$ and $f(b)$ and multiply with $h/2$.\n\n * Perform a loop over $n=1$ to $n-1$ ($f(a)$ and $f(b)$ are known) and sum up the terms $f(a+h) +f(a+2h)+f(a+3h)+\\dots +f(b-h)$. Each step in the loop corresponds to a given value $a+nh$.\n\n * Multiply the final result by $h$ and add $hf(a)/2$ and $hf(b)/2$.\n\n## Trapezoidal Rule\n\nWe use the same function and integrate now using the trapoezoidal rule.\n\n\n```\nimport numpy as np\nfrom sympy import Symbol, integrate\n# function for the trapezoidal rule\ndef Trapez(a,b,f,n):\n h = (b-a)/float(n)\n s = 0\n x = a\n for i in range(1,n,1):\n x = x+h\n s = s+ f(x)\n s = 0.5*(f(a)+f(b)) +s\n return h*s\n# function to integrate\ndef function(x):\n return sin(2*pi*x)\n# define integration limits and integration points \na = 0.0; b = 0.5;\nn = 100\nExact = 1./pi\nprint(\"Relative error= \", abs( (Trapez(a,b,function,n)-Exact)/Exact))\n```\n\n## Simpsons' rule\n\nInstead of using the above first-order polynomials \napproximations for $f$, we attempt at using a second-order polynomials.\nIn this case we need three points in order to define a second-order \npolynomial approximation\n\n$$\nf(x) \\approx P_2(x)=a_0+a_1x+a_2x^2.\n$$\n\nUsing again Lagrange's interpolation formula we have\n\n$$\nP_2(x)=\\frac{(x-x_0)(x-x_1)}{(x_2-x_0)(x_2-x_1)}y_2+\n \\frac{(x-x_0)(x-x_2)}{(x_1-x_0)(x_1-x_2)}y_1+\n \\frac{(x-x_1)(x-x_2)}{(x_0-x_1)(x_0-x_2)}y_0.\n$$\n\nInserting this formula in the integral of Eq. ([21](#eq:hhint)) we obtain\n\n$$\n\\int_{-h}^{+h}f(x)dx=\\frac{h}{3}\\left(f_h + 4f_0 + f_{-h}\\right)+O(h^5),\n$$\n\nwhich is Simpson's rule.\n\n## Simpson's rule\nNote that the improved accuracy in the evaluation of\nthe derivatives gives a better error approximation, $O(h^5)$ vs.\\ $O(h^3)$ .\nBut this is again the *local error approximation*. \nUsing Simpson's rule we can easily compute\nthe integral of Eq. ([20](#eq:integraldef)) to be\n\n\n
\n\n$$\n\\begin{equation}\n I=\\int_a^bf(x) dx=\\frac{h}{3}\\left(f(a) + 4f(a+h) +2f(a+2h)+\n \\dots +4f(b-h)+ f_{b}\\right),\n\\label{eq:simpson} \\tag{25}\n\\end{equation}\n$$\n\nwith a global error which goes like $O(h^4)$.\n\n## Mathematical expressions for the truncation error\nMore formal expressions for the local and global errors are for the local error\n\n$$\n\\int_a^bf(x)dx -\\frac{b-a}{6}\\left[f(a)+4f((a+b)/2)+f(b)\\right]=-\\frac{h^5}{90}f^{(4)}(\\xi),\n$$\n\nand for the global error\n\n$$\n\\int_a^bf(x)dx -S_h(f)=-\\frac{b-a}{180}h^4f^{(4)}(\\xi).\n$$\n\nwith $\\xi\\in[a,b]$ and $S_h$ the results obtained with Simpson's method.\n\n## Algorithm for Simpson's rule\nThe method \ncan easily be implemented numerically through the following simple algorithm\n\n * Choose the number of mesh points and fix the step.\n\n * calculate $f(a)$ and $f(b)$\n\n * Perform a loop over $n=1$ to $n-1$ ($f(a)$ and $f(b)$ are known) and sum up the terms $4f(a+h) +2f(a+2h)+4f(a+3h)+\\dots +4f(b-h)$. Each step in the loop corresponds to a given value $a+nh$. Odd values of $n$ give $4$ as factor while even values yield $2$ as factor.\n\n * Multiply the final result by $\\frac{h}{3}$.\n\n## Code example\n\n\n```\nfrom math import sin, pi\nimport numpy as np\nfrom sympy import Symbol, integrate\n# function for the trapezoidal rule \ndef Simpson(a,b,f,n):\n h = (b-a)/float(n)\n sum = f(a)/float(2);\n for i in range(1,n):\n sum = sum + f(a+i*h)*(3+(-1)**(i+1))\n sum = sum + f(b)/float(2)\n return sum*h/3.0\n# function to integrate \ndef function(x):\n return sin(2*pi*x)\n# define integration limits and integration points \na = 0.0; b = 0.5;\nn = 100\nExact = 1./pi\nprint(\"Relative error= \", abs( (Simpson(a,b,function,n)-Exact)/Exact))\n```\n\nWe see that Simpson's rule gives a much better estimation of the relative error with the same amount of points as we had for the Rectangle rule and the Trapezoidal rule.\n\n## Symbolic integration\n\nWe could also use the symbolic mathematics. Here Python comes to our rescue with [SymPy](https://www.sympy.org/en/index.html), which is a Python library for symbolic mathematics.\n\nHere's an example on how you could use **Sympy** where we compare the symbolic calculation with an\nintegration of a function $f(x)$ by the Trapezoidal rule.\nHere we show an\nexample code that evaluates the integral\n$\\int_0^1 dx x^2 = 1/3$.\nThe following code for the trapezoidal rule allows you to plot the relative error by comparing with the exact result. By increasing to $10^8$ points one arrives at a region where numerical errors start to accumulate.\n\n\n```\nfrom math import log10\nimport numpy as np\nfrom sympy import Symbol, integrate\nimport matplotlib.pyplot as plt\n# function for the trapezoidal rule\ndef Trapez(a,b,f,n):\n h = (b-a)/float(n)\n s = 0\n x = a\n for i in range(1,n,1):\n x = x+h\n s = s+ f(x)\n s = 0.5*(f(a)+f(b)) +s\n return h*s\n# function to compute pi\ndef function(x):\n return x*x\n# define integration limits\na = 0.0; b = 1.0;\n# find result from sympy\n# define x as a symbol to be used by sympy\nx = Symbol('x')\nexact = integrate(function(x), (x, a, b))\n# set up the arrays for plotting the relative error\nn = np.zeros(9); y = np.zeros(9);\n# find the relative error as function of integration points\nfor i in range(1, 8, 1):\n npts = 10**i\n result = Trapez(a,b,function,npts)\n RelativeError = abs((exact-result)/exact)\n n[i] = log10(npts); y[i] = log10(RelativeError);\nplt.plot(n,y, 'ro')\nplt.xlabel('n')\nplt.ylabel('Relative error')\nplt.show()\n```\n", "meta": {"hexsha": "5136b604c74b087aeec21653d16e444d36e95c7b", "size": 84574, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/week4/ipynb/week4.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/pub/week4/ipynb/week4.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/pub/week4/ipynb/week4.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.5039172673, "max_line_length": 366, "alphanum_fraction": 0.5465509495, "converted": true, "num_tokens": 13650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3486451488696663, "lm_q2_score": 0.4263215925474903, "lm_q1q2_score": 0.14863495510007296}}
{"text": " \n#### Procesamiento Digital de Señales\n\n# Trabajo Práctico Nº0\n#### Nombre y Apellido\n\n\n# Introducción\nJupyter Notebook es una herramienta para la confección de reportes técnicos, dado que permite la interacción en el mismo ambiente de: \n1. un procesador de texto elemental (formato Markdown) que permite resaltar texto, en forma de *itálica* o **negrita** de manera muy legible (haciendo doble click en este texto podrás ver el código fuente estilo Markdown). Cuenta con estilos predefinidos:\n\n# Título 1\n## Título 2\n### Título 3\n\ny también la capacidad de incluir enlaces a otras páginas, como por ejemplo [esta página](https://medium.com/ibm-data-science-experience/markdown-for-jupyter-notebooks-cheatsheet-386c05aeebed) donde encontrarás más funcionalidades del lenguaje **Markdown**\n\n2. capacidad para incluir lenguaje matemático estilo LaTex, tanto de forma presentada\n\n\\begin{equation}\nT(z) = \\frac{Y(z)}{X(z)} = \\frac{ b_2 \\, z^{-2} + b_1 \\, z^{-1} + b_0 }\n{a_2 \\, z^{-2} + a_1 \\, z^{-1} + a_0}\n\\end{equation}\n\ncomo *inline* en el propio párrafo $y[k] = \\frac{1}{a_0} \\left( \\sum_{m=0}^{M} b_m \\; x[k-m] - \\sum_{n=1}^{N} a_n \\; y[k-n] \\right) $\n\n3. La posibilidad de incluir scripts en Python, como los que usaremos para las simulaciones en los TPs de la materia. En este caso usaremos el *testbench0.py* como ejemplo. Una vez que lo probamos y estamos seguros que funciona de forma esperada en *Spyder*, podemos incluir los resultados de la simulación de manera casi transparente. Solo tenemos que agregar una celda de código donde incluimos el código, y los resultados directamente quedan incluidos en este documento.\n\n\n```python\n# Módulos para Jupyter\nimport warnings\nwarnings.filterwarnings('ignore')\n\nimport numpy as np\nimport matplotlib as mpl\n#%% Inicialización de librerías\n# Setup inline graphics: Esto lo hacemos para que el tamaño de la salida, \n# sea un poco más adecuada al tamaño del documento\nmpl.rcParams['figure.figsize'] = (10,10)\n\nimport matplotlib.pyplot as plt\nimport pdsmodulos as pds\n\n#%% Esto tiene que ver con cuestiones de presentación de los gráficos,\n# NO ES IMPORTANTE\nfig_sz_x = 14\nfig_sz_y = 13\nfig_dpi = 80 # dpi\n\nfig_font_family = 'Ubuntu'\nfig_font_size = 16\n\nplt.rcParams.update({'font.size':fig_font_size})\nplt.rcParams.update({'font.family':fig_font_family})\n\n##############################################\n#%% A partir de aquí comienza lo IMPORTANTE #\n#############################################\n\ndef my_testbench( sig_type ):\n \n # Datos generales de la simulación\n fs = 1000.0 # frecuencia de muestreo (Hz)\n N = 1000 # cantidad de muestras\n \n ts = 1/fs # tiempo de muestreo\n df = fs/N # resolución espectral\n \n # grilla de sampleo temporal\n tt = np.linspace(0, (N-1)*ts, N).flatten()\n \n # grilla de sampleo frecuencial\n ff = np.linspace(0, (N-1)*df, N).flatten()\n\n # Concatenación de matrices:\n # guardaremos las señales creadas al ir poblando la siguiente matriz vacía\n x = np.array([], dtype=np.float).reshape(N,0)\n ii = 0\n \n # estructuras de control de flujo\n if sig_type['tipo'] == 'senoidal':\n \n \n # calculo cada senoidal de acuerdo a sus parámetros\n for this_freq in sig_type['frecuencia']:\n # prestar atención que las tuplas dentro de los diccionarios también pueden direccionarse mediante \"ii\"\n aux = sig_type['amplitud'][ii] * np.sin( 2*np.pi*this_freq*tt + sig_type['fase'][ii] )\n # para concatenar horizontalmente es necesario cuidar que tengan iguales FILAS\n x = np.hstack([x, aux.reshape(N,1)] )\n ii += 1\n \n elif sig_type['tipo'] == 'ruido':\n \n # calculo cada señal de ruido incorrelado (blanco), Gausiano de acuerdo a sus parámetros\n # de varianza\n for this_var in sig_type['varianza']:\n aux = np.sqrt(this_var) * np.random.randn(N,1)\n # para concatenar horizontalmente es necesario cuidar que tengan iguales FILAS\n x = np.hstack([x, aux] )\n \n # Podemos agregar algún dato extra a la descripción de forma programática\n # {0:.3f} significa 0: primer argunmento de format\n # .3f formato flotante, con 3 decimales\n # $ ... $ indicamos que incluiremos sintaxis LaTex: $\\hat{{\\sigma}}^2$\n sig_props['descripcion'] = [ sig_props['descripcion'][ii] + ' - $\\hat{{\\sigma}}^2$ :{0:.3f}'.format( np.var(x[:,ii])) for ii in range(0,len(sig_props['descripcion'])) ]\n \n else:\n \n print(\"Tipo de señal no implementado.\") \n return\n \n #%% Presentación gráfica de los resultados\n \n plt.figure(1)\n line_hdls = plt.plot(tt, x)\n plt.title('Señal: ' + sig_type['tipo'] )\n plt.xlabel('tiempo [segundos]')\n plt.ylabel('Amplitud [V]')\n # plt.grid(which='both', axis='both')\n \n # presentar una leyenda para cada tipo de señal\n axes_hdl = plt.gca()\n \n # este tipo de sintaxis es *MUY* de Python\n axes_hdl.legend(line_hdls, sig_type['descripcion'], loc='upper right' )\n \n plt.show()\n\n```\n\nDado que nuestro *testbench* ha sido desarrollado de manera funcional, llamando a la función *my_testbench()* con diferentes parámetros, podemos lograr funcionalidades diferentes, como mostramos a continuación primero con una senoidal:\n\n\n```python\nsig_props = { 'tipo': 'senoidal', \n 'frecuencia': (3, 10, 20), # Uso de tuplas para las frecuencias \n 'amplitud': (1, 1, 1),\n 'fase': (0, 0, 0)\n } \n# Como también puedo agregar un campo descripción de manera programática\n# este tipo de sintaxis es *MUY* de Python\nsig_props['descripcion'] = [ str(a_freq) + ' Hz' for a_freq in sig_props['frecuencia'] ]\n \n# Invocamos a nuestro testbench exclusivamente: \nmy_testbench( sig_props )\n```\n\nY ahora con una señal aleatoria, en este caso ruido blanco Gaussiano incorrelado de varianza $\\sigma^2$:\n\n\n```python\n# Usar CTRL+1 para comentar o descomentar el bloque de abajo.\nsig_props = { 'tipo': 'ruido', \n 'varianza': (1, 1, 1) # Uso de tuplas para las frecuencias \n } \nsig_props['descripcion'] = [ '$\\sigma^2$ = ' + str(a_var) for a_var in sig_props['varianza'] ]\n \n# Invocamos a nuestro testbench exclusivamente: \nmy_testbench( sig_props )\n\n```\n\nComo puede verse en la figura anterior, al samplear una distribución estadística de media nula y varianza $\\sigma^2=1$, obtenemos realizaciones cuyo parámetro $\\sigma^2$ estimado, es decir $\\hat\\sigma^2$, tienen una desviación respecto al verdadero valor (sesgo). Nos ocuparemos de estudiar el sesgo y la varianza de algunos estimadores cuando veamos **Estimación Espectral**.\n\n# Una vez terminado ...\nUna vez que hayas termiando con la confección del documento, podemos utilizar una ventaja muy importante de este tipo de documentos que es la posibilidad de compartirlos *online* mediante la [página de nbviewer](http://nbviewer.jupyter.org/). Para ello es necesario que tu notebook y todos los recursos asociados estén alojados en un repositorio de [Github](https://github.com/). Como ejemplo, podés ver este mismo documento disponible [online](http://nbviewer.jupyter.org/github/marianux/pdstestbench/blob/master/notebook0.ipynb).\n", "meta": {"hexsha": "e4c357d6baf1a706d24c07e009b46bc879132848", "size": 127105, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook0.ipynb", "max_stars_repo_name": "yaninacorsaro/test", "max_stars_repo_head_hexsha": "2e0c35d1e2e875beb1537c78470ce7f56518b4cb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebook0.ipynb", "max_issues_repo_name": "yaninacorsaro/test", "max_issues_repo_head_hexsha": "2e0c35d1e2e875beb1537c78470ce7f56518b4cb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebook0.ipynb", "max_forks_repo_name": "yaninacorsaro/test", "max_forks_repo_head_hexsha": "2e0c35d1e2e875beb1537c78470ce7f56518b4cb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-09-02T18:39:57.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-09T21:59:52.000Z", "avg_line_length": 498.4509803922, "max_line_length": 72496, "alphanum_fraction": 0.9382479053, "converted": true, "num_tokens": 2017, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.30404168757891037, "lm_q1q2_score": 0.14845850752250575}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n%matplotlib inline\n%config InlineBackend.figure_format='retina'\n\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nimport seaborn as sns\nsns.set(font_scale=1.5, style='ticks')\n```\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nimport pandas as pd\n```\n\n\n```python\ncount_data = np.loadtxt(\"data/txtdata.csv\")\ncount_data = pd.Series(count_data)\nn_count_data = len(count_data)\n```\n\n\n```python\ncount_data\n```\n\n\n\n\n 0 13.0\n 1 24.0\n 2 8.0\n 3 24.0\n 4 7.0\n 5 35.0\n 6 14.0\n 7 11.0\n 8 15.0\n 9 11.0\n 10 22.0\n 11 22.0\n 12 11.0\n 13 57.0\n 14 11.0\n 15 19.0\n 16 29.0\n 17 6.0\n 18 19.0\n 19 12.0\n 20 22.0\n 21 12.0\n 22 18.0\n 23 72.0\n 24 32.0\n 25 9.0\n 26 7.0\n 27 13.0\n 28 19.0\n 29 23.0\n ... \n 44 19.0\n 45 70.0\n 46 49.0\n 47 7.0\n 48 53.0\n 49 22.0\n 50 21.0\n 51 31.0\n 52 19.0\n 53 11.0\n 54 18.0\n 55 20.0\n 56 12.0\n 57 35.0\n 58 17.0\n 59 23.0\n 60 17.0\n 61 4.0\n 62 2.0\n 63 31.0\n 64 30.0\n 65 13.0\n 66 27.0\n 67 0.0\n 68 39.0\n 69 37.0\n 70 5.0\n 71 14.0\n 72 13.0\n 73 22.0\n Length: 74, dtype: float64\n\n\n\n\n```python\nfigsize(15,5)\nplt.bar(np.arange(n_count_data), \n count_data, \n alpha=0.8,\n color=\"#348ABD\")\n\nax = plt.gca()\n\ncount_data.rolling(window=5,\n win_type='gaussian',\n min_periods=1,\n center=True).mean(std=2).plot(ax=ax)\n \n\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. **A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data.** Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\n WARNING (theano.configdefaults): install mkl with `conda install mkl-service`: No module named 'mkl'\n\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n Multiprocess sampling (2 chains in 2 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n Sampling 2 chains: 100%|██████████| 30000/30000 [00:08<00:00, 3526.72draws/s]\n The number of effective samples is smaller than 25% for some parameters.\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\n(44 < tau_samples)\n```\n\n\n\n\n array([False, True, True, ..., True, False, False])\n\n\n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\nprint(lambda_1_samples.mean())\nprint(lambda_2_samples.mean())\n```\n\n 17.753978108380828\n 22.723803317605842\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n#type your code here.\nprint( ((lambda_2_samples - lambda_1_samples) / lambda_1_samples).mean() )\n```\n\n 0.28147995232483525\n\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n#type your code here.\nix = tau_samples < 45\nprint(lambda_1_samples[ix].mean())\n```\n\n 17.746674012065846\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "276545463b115bd3b46d937dd817c49c61de021b", "size": 770853, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "josesho/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "127d7ebc3fd510544576978fe240b0f34bcf7466", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "josesho/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "127d7ebc3fd510544576978fe240b0f34bcf7466", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "josesho/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "127d7ebc3fd510544576978fe240b0f34bcf7466", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 576.5542258788, "max_line_length": 196908, "alphanum_fraction": 0.9361175218, "converted": true, "num_tokens": 12028, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4571367168274948, "lm_q2_score": 0.32423540551084407, "lm_q1q2_score": 0.14821990875445867}}
{"text": "\n# PHY321: More on Motion and Forces, begin Work and Energy discussion\n\n \n**[Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/)**, Department of Physics and Astronomy and Facility for Rare Ion Beams (FRIB), Michigan State University, USA and Department of Physics, University of Oslo, Norway\n\nDate: **Feb 3, 2021**\n\nCopyright 1999-2021, [Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/). Released under CC Attribution-NonCommercial 4.0 license\n\n\n\n\n## Aims and Overarching Motivation\n\n### Monday\n\nWe discuss various forces and their pertinent equations of motion\n\nRecommended reading: Taylor 2.1-2.4. Malthe-Sørenssen chapter 6-7 contains many examples.\nWe will cover in particular a falling object in two dimensions with linear air resistance relevant for homework 3. \n\n### Wednesday\n\nWe discuss other force models with examples such as the gravitational\nforce and a spring force. See Malthe-Sørenssen chapter 7.3-7.5. We\nstart our discussion of energy and work, see Taylor 4.1\n\nWe discuss also exercise 5 from homework 2.\n\n### Friday\n\nWe discuss several examples of energy and work. Taylor 4.1-4.3.\n\n\n\n\n\n\n## Air Resistance in One Dimension\n\nLast week we considered the motion of a falling object with air\nresistance. Here we look at both a quadratic in velocity resistance\nand linear in velocity. But first we give a qualitative argument\nabout the mathematical expression for the air resistance we used last\nFriday.\n\n\nAir resistance tends to scale as the square of the velocity. This is\nin contrast to many problems chosen for textbooks, where it is linear\nin the velocity. The choice of a linear dependence is motivated by\nmathematical simplicity (it keeps the differential equation linear)\nrather than by physics. One can see that the force should be quadratic\nin velocity by considering the momentum imparted on the air\nmolecules. If an object sweeps through a volume $dV$ of air in time\n$dt$, the momentum imparted on the air is\n\n\n
\n\n$$\n\\begin{equation}\ndP=\\rho_m dV v,\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nwhere $v$ is the velocity of the object and $\\rho_m$ is the mass\ndensity of the air. If the molecules bounce back as opposed to stop\nyou would double the size of the term. The opposite value of the\nmomentum is imparted onto the object itself. Geometrically, the\ndifferential volume is\n\n\n
\n\n$$\n\\begin{equation}\ndV=Avdt,\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nwhere $A$ is the cross-sectional area and $vdt$ is the distance the\nobject moved in time $dt$.\n\n## Resulting Acceleration\nPlugging this into the expression above,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dP}{dt}=-\\rho_m A v^2.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\nThis is the force felt by the particle, and is opposite to its\ndirection of motion. Now, because air doesn't stop when it hits an\nobject, but flows around the best it can, the actual force is reduced\nby a dimensionless factor $c_W$, called the drag coefficient.\n\n\n
\n\n$$\n\\begin{equation}\nF_{\\rm drag}=-c_W\\rho_m Av^2,\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nand the acceleration is\n\n$$\n\\begin{eqnarray}\n\\frac{dv}{dt}=-\\frac{c_W\\rho_mA}{m}v^2.\n\\end{eqnarray}\n$$\n\nFor a particle with initial velocity $v_0$, one can separate the $dt$\nto one side of the equation, and move everything with $v$s to the\nother side. We did this in our discussion of simple motion and will not repeat it here.\n\nOn more general terms,\nfor many systems, e.g. an automobile, there are multiple sources of\nresistance. In addition to wind resistance, where the force is\nproportional to $v^2$, there are dissipative effects of the tires on\nthe pavement, and in the axel and drive train. These other forces can\nhave components that scale proportional to $v$, and components that\nare independent of $v$. Those independent of $v$, e.g. the usual\n$f=\\mu_K N$ frictional force you consider in your first Physics courses, only set in\nonce the object is actually moving. As speeds become higher, the $v^2$\ncomponents begin to dominate relative to the others. For automobiles\nat freeway speeds, the $v^2$ terms are largely responsible for the\nloss of efficiency. To travel a distance $L$ at fixed speed $v$, the\nenergy/work required to overcome the dissipative forces are $fL$,\nwhich for a force of the form $f=\\alpha v^n$ becomes\n\n$$\n\\begin{eqnarray}\nW=\\int dx~f=\\alpha v^n L.\n\\end{eqnarray}\n$$\n\nFor $n=0$ the work is\nindependent of speed, but for the wind resistance, where $n=2$,\nslowing down is essential if one wishes to reduce fuel consumption. It\nis also important to consider that engines are designed to be most\nefficient at a chosen range of power output. Thus, some cars will get\nbetter mileage at higher speeds (They perform better at 50 mph than at\n5 mph) despite the considerations mentioned above.\n\n## Going Ballistic, Projectile Motion or a Softer Approach, Falling Raindrops\n\n\nAs an example of Newton's Laws we consider projectile motion (or a\nfalling raindrop or a ball we throw up in the air) with a drag force. Even though air resistance is\nlargely proportional to the square of the velocity, we will consider\nthe drag force to be linear to the velocity, $\\boldsymbol{F}=-m\\gamma\\boldsymbol{v}$,\nfor the purposes of this exercise.\n\nSuch a dependence can be extracted from experimental data for objects moving at low velocities, see for example Malthe-Sørenssen chapter 5.6.\n\nWe will here focus on a two-dimensional problem.\n\n## Two-dimensional falling object\n\nThe acceleration for a projectile moving upwards,\n$\\boldsymbol{a}=\\boldsymbol{F}/m$, becomes\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{dt}=-\\gamma v_x,\\\\\n\\nonumber\n\\frac{dv_y}{dt}=-\\gamma v_y-g,\n\\end{eqnarray}\n$$\n\nand $\\gamma$ has dimensions of inverse time. \n\nIf you on the other hand have a falling raindrop, how do these equations change? See for example Figure 2.1 in Taylor.\nLet us stay with a ball which is thrown up in the air at $t=0$. \n\n## Ways of solving these equations\n\nWe will go over two different ways to solve this equation. The first\nby direct integration, and the second as a differential equation. To\ndo this by direct integration, one simply multiplies both sides of the\nequations above by $dt$, then divide by the appropriate factors so\nthat the $v$s are all on one side of the equation and the $dt$ is on\nthe other. For the $x$ motion one finds an easily integrable equation,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{v_x}&=&-\\gamma dt,\\\\\n\\nonumber\n\\int_{v_{0x}}^{v_{x}}\\frac{dv_x}{v_x}&=&-\\gamma\\int_0^{t}dt,\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{x}}{v_{0x}}\\right)&=&-\\gamma t,\\\\\n\\nonumber\nv_{x}(t)&=&v_{0x}e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nThis is very much the result you would have written down\nby inspection. For the $y$-component of the velocity,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_y}{v_y+g/\\gamma}&=&-\\gamma dt\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{y}+g/\\gamma}{v_{0y}-g/\\gamma}\\right)&=&-\\gamma t_f,\\\\\n\\nonumber\nv_{fy}&=&-\\frac{g}{\\gamma}+\\left(v_{0y}+\\frac{g}{\\gamma}\\right)e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nWhereas $v_x$ starts at some value and decays\nexponentially to zero, $v_y$ decays exponentially to the terminal\nvelocity, $v_t=-g/\\gamma$.\n\n## Solving as differential equations\n\nAlthough this direct integration is simpler than the method we invoke\nbelow, the method below will come in useful for some slightly more\ndifficult differential equations in the future. The differential\nequation for $v_x$ is straight-forward to solve. Because it is first\norder there is one arbitrary constant, $A$, and by inspection the\nsolution is\n\n\n
\n\n$$\n\\begin{equation}\nv_x=Ae^{-\\gamma t}.\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\nThe arbitrary constants for equations of motion are usually determined\nby the initial conditions, or more generally boundary conditions. By\ninspection $A=v_{0x}$, the initial $x$ component of the velocity.\n\n\n## Differential Equations, contn\nThe differential equation for $v_y$ is a bit more complicated due to\nthe presence of $g$. Differential equations where all the terms are\nlinearly proportional to a function, in this case $v_y$, or to\nderivatives of the function, e.g., $v_y$, $dv_y/dt$,\n$d^2v_y/dt^2\\cdots$, are called linear differential equations. If\nthere are terms proportional to $v^2$, as would happen if the drag\nforce were proportional to the square of the velocity, the\ndifferential equation is not longer linear. Because this expression\nhas only one derivative in $v$ it is a first-order linear differential\nequation. If a term were added proportional to $d^2v/dt^2$ it would be\na second-order differential equation. In this case we have a term\ncompletely independent of $v$, the gravitational acceleration $g$, and\nthe usual strategy is to first rewrite the equation with all the\nlinear terms on one side of the equal sign,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_y}{dt}+\\gamma v_y=-g.\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\n## Splitting into two parts\n\nNow, the solution to the equation can be broken into two\nparts. Because this is a first-order differential equation we know\nthat there will be one arbitrary constant. Physically, the arbitrary\nconstant will be determined by setting the initial velocity, though it\ncould be determined by setting the velocity at any given time. Like\nmost differential equations, solutions are not \"solved\". Instead,\none guesses at a form, then shows the guess is correct. For these\ntypes of equations, one first tries to find a single solution,\ni.e. one with no arbitrary constants. This is called the {\\it\nparticular} solution, $y_p(t)$, though it should really be called\n\"a\" particular solution because there are an infinite number of such\nsolutions. One then finds a solution to the {\\it homogenous} equation,\nwhich is the equation with zero on the right-hand side,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,h}}{dt}+\\gamma v_{y,h}=0.\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nHomogenous solutions will have arbitrary constants. \n\nThe particular solution will solve the same equation as the original\ngeneral equation\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,p}}{dt}+\\gamma v_{y,p}=-g.\n\\label{_auto8} \\tag{8}\n\\end{equation}\n$$\n\nHowever, we don't need find one with arbitrary constants. Hence, it is\ncalled a **particular** solution.\n\nThe sum of the two,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=v_{y,p}+v_{y,h},\n\\label{_auto9} \\tag{9}\n\\end{equation}\n$$\n\nis a solution of the total equation because of the linear nature of\nthe differential equation. One has now found a *general* solution\nencompassing all solutions, because it both satisfies the general\nequation (like the particular solution), and has an arbitrary constant\nthat can be adjusted to fit any initial condition (like the homogeneous\nsolution). If the equations were not linear, that is if there were terms\nsuch as $v_y^2$ or $v_y\\dot{v}_y$, this technique would not work.\n\n## More details\n\nReturning to the example above, the homogenous solution is the same as\nthat for $v_x$, because there was no gravitational acceleration in\nthat case,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,h}=Be^{-\\gamma t}.\n\\label{_auto10} \\tag{10}\n\\end{equation}\n$$\n\nIn this case a particular solution is one with constant velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,p}=-g/\\gamma.\n\\label{_auto11} \\tag{11}\n\\end{equation}\n$$\n\nNote that this is the terminal velocity of a particle falling from a\ngreat height. The general solution is thus,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=Be^{-\\gamma t}-g/\\gamma,\n\\label{_auto12} \\tag{12}\n\\end{equation}\n$$\n\nand one can find $B$ from the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{0y}=B-g/\\gamma,~~~B=v_{0y}+g/\\gamma.\n\\label{_auto13} \\tag{13}\n\\end{equation}\n$$\n\nPlugging in the expression for $B$ gives the $y$ motion given the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=(v_{0y}+g/\\gamma)e^{-\\gamma t}-g/\\gamma.\n\\label{_auto14} \\tag{14}\n\\end{equation}\n$$\n\nIt is easy to see that this solution has $v_y=v_{0y}$ when $t=0$ and\n$v_y=-g/\\gamma$ when $t\\rightarrow\\infty$.\n\nOne can also integrate the two equations to find the coordinates $x$\nand $y$ as functions of $t$,\n\n$$\n\\begin{eqnarray}\nx&=&\\int_0^t dt'~v_{0x}(t')=\\frac{v_{0x}}{\\gamma}\\left(1-e^{-\\gamma t}\\right),\\\\\n\\nonumber\ny&=&\\int_0^t dt'~v_{0y}(t')=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\end{eqnarray}\n$$\n\nIf the question was to find the position at a time $t$, we would be\nfinished. However, the more common goal in a projectile equation\nproblem is to find the range, i.e. the distance $x$ at which $y$\nreturns to zero. For the case without a drag force this was much\nsimpler. The solution for the $y$ coordinate would have been\n$y=v_{0y}t-gt^2/2$. One would solve for $t$ to make $y=0$, which would\nbe $t=2v_{0y}/g$, then plug that value for $t$ into $x=v_{0x}t$ to\nfind $x=2v_{0x}v_{0y}/g=v_0\\sin(2\\theta_0)/g$. One follows the same\nsteps here, except that the expression for $y(t)$ is more\ncomplicated. Searching for the time where $y=0$, and we get\n\n\n
\n\n$$\n\\begin{equation}\n0=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\label{_auto15} \\tag{15}\n\\end{equation}\n$$\n\nThis cannot be inverted into a simple expression $t=\\cdots$. Such\nexpressions are known as \"transcendental equations\", and are not the\nrare instance, but are the norm. In the days before computers, one\nmight plot the right-hand side of the above graphically as\na function of time, then find the point where it crosses zero.\n\nNow, the most common way to solve for an equation of the above type\nwould be to apply Newton's method numerically. This involves the\nfollowing algorithm for finding solutions of some equation $F(t)=0$.\n\n1. First guess a value for the time, $t_{\\rm guess}$.\n\n2. Calculate $F$ and its derivative, $F(t_{\\rm guess})$ and $F'(t_{\\rm guess})$. \n\n3. Unless you guessed perfectly, $F\\ne 0$, and assuming that $\\Delta F\\approx F'\\Delta t$, one would choose \n\n4. $\\Delta t=-F(t_{\\rm guess})/F'(t_{\\rm guess})$.\n\n5. Now repeat step 1, but with $t_{\\rm guess}\\rightarrow t_{\\rm guess}+\\Delta t$.\n\nIf the $F(t)$ were perfectly linear in $t$, one would find $t$ in one\nstep. Instead, one typically finds a value of $t$ that is closer to\nthe final answer than $t_{\\rm guess}$. One breaks the loop once one\nfinds $F$ within some acceptable tolerance of zero. A program to do\nthis will be added shortly.\n\n## Motion in a Magnetic Field\n\n\nAnother example of a velocity-dependent force is magnetism,\n\n$$\n\\begin{eqnarray}\n\\boldsymbol{F}&=&q\\boldsymbol{v}\\times\\boldsymbol{B},\\\\\n\\nonumber\nF_i&=&q\\sum_{jk}\\epsilon_{ijk}v_jB_k.\n\\end{eqnarray}\n$$\n\nFor a uniform field in the $z$ direction $\\boldsymbol{B}=B\\hat{z}$, the force can only have $x$ and $y$ components,\n\n$$\n\\begin{eqnarray}\nF_x&=&qBv_y\\\\\n\\nonumber\nF_y&=&-qBv_x.\n\\end{eqnarray}\n$$\n\nThe differential equations are\n\n$$\n\\begin{eqnarray}\n\\dot{v}_x&=&\\omega_c v_y,\\omega_c= qB/m\\\\\n\\nonumber\n\\dot{v}_y&=&-\\omega_c v_x.\n\\end{eqnarray}\n$$\n\nOne can solve the equations by taking time derivatives of either equation, then substituting into the other equation,\n\n$$\n\\begin{eqnarray}\n\\ddot{v}_x=\\omega_c\\dot{v_y}=-\\omega_c^2v_x,\\\\\n\\nonumber\n\\ddot{v}_y&=&-\\omega_c\\dot{v}_x=-\\omega_cv_y.\n\\end{eqnarray}\n$$\n\nThe solution to these equations can be seen by inspection,\n\n$$\n\\begin{eqnarray}\nv_x&=&A\\sin(\\omega_ct+\\phi),\\\\\n\\nonumber\nv_y&=&A\\cos(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nOne can integrate the equations to find the positions as a function of time,\n\n$$\n\\begin{eqnarray}\nx-x_0&=&\\int_{x_0}^x dx=\\int_0^t dt v(t)\\\\\n\\nonumber\n&=&\\frac{-A}{\\omega_c}\\cos(\\omega_ct+\\phi),\\\\\n\\nonumber\ny-y_0&=&\\frac{A}{\\omega_c}\\sin(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nThe trajectory is a circle centered at $x_0,y_0$ with amplitude $A$ rotating in the clockwise direction.\n\nThe equations of motion for the $z$ motion are\n\n\n
\n\n$$\n\\begin{equation}\n\\dot{v_z}=0,\n\\label{_auto16} \\tag{16}\n\\end{equation}\n$$\n\nwhich leads to\n\n\n
\n\n$$\n\\begin{equation}\nz-z_0=V_zt.\n\\label{_auto17} \\tag{17}\n\\end{equation}\n$$\n\nAdded onto the circle, the motion is helical.\n\nNote that the kinetic energy,\n\n\n
\n\n$$\n\\begin{equation}\nT=\\frac{1}{2}m(v_x^2+v_y^2+v_z^2)=\\frac{1}{2}m(\\omega_c^2A^2+V_z^2),\n\\label{_auto18} \\tag{18}\n\\end{equation}\n$$\n\nis constant. This is because the force is perpendicular to the\nvelocity, so that in any differential time element $dt$ the work done\non the particle $\\boldsymbol{F}\\cdot{dr}=dt\\boldsymbol{F}\\cdot{v}=0$.\n\nOne should think about the implications of a velocity dependent\nforce. Suppose one had a constant magnetic field in deep space. If a\nparticle came through with velocity $v_0$, it would undergo cyclotron\nmotion with radius $R=v_0/\\omega_c$. However, if it were still its\nmotion would remain fixed. Now, suppose an observer looked at the\nparticle in one reference frame where the particle was moving, then\nchanged their velocity so that the particle's velocity appeared to be\nzero. The motion would change from circular to fixed. Is this\npossible?\n\nThe solution to the puzzle above relies on understanding\nrelativity. Imagine that the first observer believes $\\boldsymbol{B}\\ne 0$ and\nthat the electric field $\\boldsymbol{E}=0$. If the observer then changes\nreference frames by accelerating to a velocity $\\boldsymbol{v}$, in the new\nframe $\\boldsymbol{B}$ and $\\boldsymbol{E}$ both change. If the observer moved to the\nframe where the charge, originally moving with a small velocity $v$,\nis now at rest, the new electric field is indeed $\\boldsymbol{v}\\times\\boldsymbol{B}$,\nwhich then leads to the same acceleration as one had before. If the\nvelocity is not small compared to the speed of light, additional\n$\\gamma$ factors come into play,\n$\\gamma=1/\\sqrt{1-(v/c)^2}$. Relativistic motion will not be\nconsidered in this course.\n\n\n\n## Sliding Block tied to a Wall\n\nAnother classical case is that of simple harmonic oscillations, here\nrepresented by a block sliding on a horizontal frictionless\nsurface. The block is tied to a wall with a spring. If the spring is\nnot compressed or stretched too far, the force on the block at a given\nposition $x$ is\n\n$$\nF=-kx.\n$$\n\n## Back and Forth, Sliding Block with no friction\n\nThe negative sign means that the force acts to restore the object to an equilibrium position. Newton's equation of motion for this idealized system is then\n\n$$\nm\\frac{d^2x}{dt^2}=-kx,\n$$\n\nor we could rephrase it as\n\n\n
\n\n$$\n\\frac{d^2x}{dt^2}=-\\frac{k}{m}x=-\\omega_0^2x,\n\\label{eq:newton1} \\tag{19}\n$$\n\nwith the angular frequency $\\omega_0^2=k/m$. \n\nWe will derive the above force when we start studying **harmonic oscillations**. \n\n## Final rewrite\n\nWith the position $x(t)$ and the velocity $v(t)=dx/dt$ we can reformulate Newton's equation in the following way\n\n$$\n\\frac{dx(t)}{dt}=v(t),\n$$\n\nand\n\n$$\n\\frac{dv(t)}{dt}=-\\omega_0^2x(t).\n$$\n\nWith initial conditions $x(t_0)=x_0$ and $v(t_0)=v_0$ we can in turn solve the differential equations. \n\n## Analytical Solution\n\nThe above differential equation has the advantage that it can be\nsolved analytically with general solutions on the form\n\n$$\nx(t)=A\\cos{\\omega_0t}+B\\sin{\\omega_0t},\n$$\n\nand\n\n$$\nv(t)=-\\omega_0 A\\sin{\\omega_0t}+\\omega_0 B\\cos{\\omega_0t},\n$$\n\nwhere $A$ and $B$ are constants to be determined from the initial conditions.\n\nThis provides in turn an important test for the numerical solution and\nthe development of a program for more complicated cases which cannot\nbe solved analytically.\n\nWe will discuss the above equations in more detail when we discuss harmonic oscillations.\n\n\n\n## Summarizing the various motion problems 1\n\nThe examples we have discussed above were included in order to\nillustrate various methods (which depend on the specific problem) to\nfind the solutions of the equations of motion.\nWe have solved the equations of motion in the following ways:\n\n**Solve the differential equations analytically.**\n\nWe did this for example with the following object in one or two dimensions or the sliding block. \nHere we had for example an equation set like\n\n$$\n\\frac{dv_x}{dt}=-\\gamma v_x,\n$$\n\nand\n\n$$\n\\frac{dv_y}{dt}=-\\gamma v_y-g,\n$$\n\nand $\\gamma$ has dimension of inverse time.\n\n\n\n\n## Summarizing the various motion problems 2\n\n\n**Integrate the equations.**\n\nWe could also in case we can separate the degrees of freedom integrate. Take for example one of the equations in the previous slide\n\n$$\n\\frac{dv_x}{dt}=-\\gamma v_x,\n$$\n\nwhich we can rewrite in terms of a left-hand side which depends only on the velocity and a right-hand side which depends only on time\n\n$$\n\\frac{dv_x}{v_x}=-\\gamma dt.\n$$\n\nIntegrating we have (since we can separate $v_x$ and $t$)\n\n$$\n\\int_{v_0}^{v_t}\\frac{dv_x}{v_x}=-\\int_{t_0}^{t_f}\\gamma dt,\n$$\n\nwhere $v_f$ is the velocity at a final time and $t_f$ is the final time.\nIn this case we found, after having integrated the above two sides that\n\n$$\nv_f(t)=v_0\\exp{-\\gamma t}.\n$$\n\n## Summarizing the various motion problems 3\n\n\n**Solve the differential equations numerically.**\n\n\nFinally, using for example Euler's method, we can solve the\ndifferential equations numerically. If we can compare our numerical\nsolutions with analytical solutions, we have an extra check of our\nnumerical approaches.\n\nThe example code on the next slide is relevant for homework 3. Here we deal with a falling object in two dimensions. Except for the derivations above with an\nair resistance which is linear in the velocity, homework 3 uses a quadratic velocity dependence.\n\n\n\n## Code example using Euler's methods\n\n**Note**: this code needs some additional expressions and will not run\n\n\n```python\n%matplotlib inline\n\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\n#define the gravitational acceleration\ng = 9.80655 #m/s^2\n# The mass and the drag constant D\nD = 0.00245 #mass/length kg/m\nm = 0.2 #kg, mass of falling object\nDeltaT = 0.001\n#set up final time, here just a number we have chosen\ntfinal = 1.0\n# set up number of points for all variables\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and y and arrays for analytical results\n# Note the brute force setting up of arrays for x and y, vx, vy, ax and ay\n# For hw3 you should think of using the 2-dim vectors you used in homework 2\nt = np.zeros(n)\nvy = np.zeros(n)\ny = np.zeros(n)\nvx = np.zeros(n)\nx = np.zeros(n)\n# Initial conditions\nvx[0] = 10.0 #m/s\nvy[0] = 0.0 #m/s\ny[0] = 10.0 #m\nx[0] = 0.0 #m\n# Start integrating using Euler's method\nfor i in range(n-1):\n # expression for acceleration, you need to set them up\n# ax = You need to set up the expression for force and thereby the acceleration in the x-direction\n# ay = You need to set up the expression for force and thereby the acceleration in the y-direction\n # update velocity and position\n vx[i+1] = vx[i] + DeltaT*ax\n x[i+1] = x[i] + DeltaT*vx[i]\n vy[i+1] = vy[i] + DeltaT*ay\n y[i+1] = y[i] + DeltaT*vy[i]\n # update time to next time step and compute analytical answer\n t[i+1] = t[i] + DeltaT\n# Here you need to set up the analytical solution for y(t) and x(t)\n\nif ( y[i+1] < 0.0):\n break\ndata = {'t[s]': t,\n 'Relative error in y': abs((y-yanalytic)/yanalytic),\n 'vy[m/s]': vy,\n 'Relative error in x': abs((x-xanalytic)/xanalytic),\n 'vx[m/s]': vx\n}\nNewData = pd.DataFrame(data)\ndisplay(NewData)\n# save to file\nNewData.to_csv(outfile, index=False)\n#then plot\nfig, axs = plt.subplots(4, 1)\naxs[0].plot(t, y)\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y')\naxs[1].plot(t, vy)\naxs[1].set_ylabel('vy[m/s]')\naxs[1].set_xlabel('time[s]')\naxs[2].plot(t, x)\naxs[2].set_xlim(0, tfinal)\naxs[2].set_ylabel('x')\naxs[3].plot(t, vx)\naxs[3].set_ylabel('vx[m/s]')\naxs[3].set_xlabel('time[s]')\nfig.tight_layout()\nplt.show()\n```\n\n## Work, Energy, Momentum and Conservation laws\n\nThe previous three cases have shown us how to use Newton’s laws of\nmotion to determine the motion of an object based on the forces acting\non it. For two of the cases there is an underlying assumption that we can find an analytical solution to a continuous problem.\nWith a continuous problem we mean a problem where the various variables can take any value within a finite or infinite interval. \n\nUnfortunately, in many cases we\ncannot find an exact solution to the equations of motion we get from\nNewton’s second law. The numerical approach, where we discretize the continuous problem, allows us however to study a much richer set of problems.\nFor problems involving Newton's laws and the various equations of motion we encounter, solving the equations numerically, is the standard approach.\n\nIt allows us to focus on the underlying forces. Often we end up using the same numerical algorithm for different problems.\n\nHere we introduce a commonly used technique that allows us to find the\nvelocity as a function of position without finding the position as a\nfunction of time—an alternate form of Newton’s second law. The method\nis based on a simple principle: Instead of solving the equations of\nmotion directly, we integrate the equations of motion. Such a method\nis called an integration method. \n\nThis allows us also to introduce the **work-energy** theorem. This\ntheorem allows us to find the velocity as a function of position for\nan object even in cases when we cannot solve the equations of\nmotion. This introduces us to the concept of work and kinetic energy,\nan energy related to the motion of an object.\n\nAnd finally, we will link the work-energy theorem with the principle of conservation of energy.\n\n## The Work-Energy Theorem\n\nLet us define the kinetic energy $K$ with a given velocity $\\boldsymbol{v}$\n\n$$\nK=\\frac{1}{2}mv^2,\n$$\n\nwhere $m$ is the mass of the object we are considering.\nWe assume also that there is a force $\\boldsymbol{F}$ acting on the given object\n\n$$\n\\boldsymbol{F}=\\boldsymbol{F}(\\boldsymbol{r},\\boldsymbol{v},t),\n$$\n\nwith $\\boldsymbol{r}$ the position and $t$ the time.\nIn general we assume the force is a function of all these variables.\nMany of the more central forces in Nature however, depende only on the\nposition. Examples are the gravitational force and the force derived\nfrom the Coulomb potential in electromagnetism.\n\n## Rewriting the Kinetic Energy\n\nLet us study the derivative of the kinetic energy with respect to time $t$. Its continuous form is\n\n$$\n\\frac{dK}{dt}=\\frac{1}{2}m\\frac{d\\boldsymbol{v}\\cdot\\boldsymbol{v}}{dt}.\n$$\n\nUsing our results from exercise 3 of homework 1, we can write the derivative of a vector dot product as\n\n$$\n\\frac{dK}{dt}=\\frac{1}{2}m\\frac{d\\boldsymbol{v}\\cdot\\boldsymbol{v}}{dt}= \\frac{1}{2}m\\left(\\frac{d\\boldsymbol{v}}{dt}\\cdot\\boldsymbol{v}+\\boldsymbol{v}\\cdot\\frac{d\\boldsymbol{v}}{dt}\\right)=m\\frac{d\\boldsymbol{v}}{dt}\\cdot\\boldsymbol{v}.\n$$\n\nWe know also that the acceleration is defined as\n\n$$\n\\boldsymbol{a}=\\frac{\\boldsymbol{F}}{m}=\\frac{d\\boldsymbol{v}}{dt}.\n$$\n\nWe can then rewrite the equation for the derivative of the kinetic energy as\n\n$$\n\\frac{dK}{dt}=m\\frac{d\\boldsymbol{v}}{dt}\\boldsymbol{v}=\\boldsymbol{F}\\frac{d\\boldsymbol{r}}{dt},\n$$\n\nwhere we defined the velocity as the derivative of the position with respect to time.\n\n## Discretizing\n\nLet us now discretize the above equation by letting the instantenous terms be replaced by a discrete quantity, that is\nwe let $dK\\rightarrow \\Delta K$, $dt\\rightarrow \\Delta t$, $d\\boldsymbol{r}\\rightarrow \\Delta \\boldsymbol{r}$ and $d\\boldsymbol{v}\\rightarrow \\Delta \\boldsymbol{v}$.\n\nWe have then\n\n$$\n\\frac{\\Delta K}{\\Delta t}=m\\frac{\\Delta \\boldsymbol{v}}{\\Delta t}\\boldsymbol{v}=\\boldsymbol{F}\\frac{\\Delta \\boldsymbol{r}}{\\Delta t},\n$$\n\nor by multiplying out $\\Delta t$ we have\n\n$$\n\\Delta K=\\boldsymbol{F}\\Delta \\boldsymbol{r}.\n$$\n\nWe define this quantity as the **work** done by the force $\\boldsymbol{F}$ during the displacement $\\Delta \\boldsymbol{r}$. If study the dimensionality of this problem we have mass times length squared divided by time squared, or just dimension energy.\n\n\n## Difference in kinetic energy\n\nIf we now a series of such displacements $\\Delta \\boldsymbol{r}$ $i=0,1,\\dots,n$, we have a difference in kinetic energy at a final position $\\boldsymbol{r}_n$ and an \ninitial position $\\boldsymbol{r}_0$ given by\n\n$$\n\\Delta K=\\frac{1}{2}mv_n^2-\\frac{1}{2}mv_0^2=\\sum_{i=0}^n\\boldsymbol{F}_i\\Delta \\boldsymbol{r},\n$$\n\nwhere $\\boldsymbol{F}_i$ are the forces acting at every position $\\boldsymbol{r}_i$.\n\nThe work done by acting with a force on a set of displacements can\nthen be as expressed as the difference between the initial and final\nkinetic energies.\n\nThis defines the **work-energy** theorem.\n\n## From the discrete version to the continuous version\n\nIf we take the limit $\\Delta \\boldsymbol{r}\\rightarrow 0$, we can rewrite the sum over the various displacements in terms of an integral, that is\n\n$$\n\\Delta K=\\frac{1}{2}mv_n^2-\\frac{1}{2}mv_0^2=\\sum_{i=0}^n\\boldsymbol{F}_i\\Delta \\boldsymbol{r}\\rightarrow \\int_{\\boldsymbol{r}_0}^{\\boldsymbol{r}_n}\\boldsymbol{F}(\\boldsymbol{r},\\boldsymbol{v},t)d\\boldsymbol{r}.\n$$\n\nThis integral defines a path integral since it will depend on the given path we take between the two end points. We will replace the limits with the symbol $c$ in order to indicate that we take a specific countour in space when the force acts on the system. That is the work $W_{n0}$ between two points $\\boldsymbol{r}_n$ and $\\boldsymbol{r}_0$ is labeled as\n\n$$\nW_{n0}=\\frac{1}{2}mv_n^2-\\frac{1}{2}mv_0^2=\\int_{c}\\boldsymbol{F}(\\boldsymbol{r},\\boldsymbol{v},t)d\\boldsymbol{r}.\n$$\n\nNote that if the force is perpendicular to the displacement, then the force does not affect the kinetic energy.\n\nLet us now study some examples of forces and how to find the velocity from the integration over a given path.\n", "meta": {"hexsha": "eb2b1862f23c83539a483d5c2918a657c5f28e75", "size": 47663, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/week5/ipynb/.ipynb_checkpoints/week5-checkpoint.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2020-01-09T17:41:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T00:48:58.000Z", "max_issues_repo_path": "doc/pub/week5/ipynb/.ipynb_checkpoints/week5-checkpoint.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-08T03:47:53.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-15T15:02:57.000Z", "max_forks_repo_path": "doc/pub/week5/ipynb/.ipynb_checkpoints/week5-checkpoint.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2020-01-10T20:40:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T20:28:41.000Z", "avg_line_length": 30.8698186528, "max_line_length": 366, "alphanum_fraction": 0.5709460168, "converted": true, "num_tokens": 8806, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.33458943461801643, "lm_q1q2_score": 0.14777912125136705}}
{"text": "\n# Computational Physics Lectures: Introduction to programming (C++ and Fortran)\n\n **Morten Hjorth-Jensen**, Department of Physics, University of Oslo and Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University\n\nDate: **2016**\n\n## Extremely useful tools, strongly recommended\n\n**and discussed at the lab sessions the first two weeks.**\n\n * GIT for version control, discussed at the lab this week (and next week as well)\n\n * ipython notebook, mentioned this week \n\n * QTcreator for editing and mastering computational projects\n\n * Armadillo as a useful numerical library for C++, highly recommended\n\n * Unit tests\n\n\n\n## A structured programming approach\n\n * Before writing a single line, have the algorithm clarified and understood. It is crucial to have a logical structure of e.g., the flow and organization of data before one starts writing.\n\n * Always try to choose the simplest algorithm. Computational speed can be improved upon later.\n\n * Try to write a as clear program as possible. Such programs are easier to debug, and although it may take more time, in the long run it may save you time. If you collaborate with other people, it reduces spending time on debuging and trying to understand what the codes do. A clear program will also allow you to remember better what the program really does!\n\n\n\n## A structured programming approach\n\n * The planning of the program should be from top down to bottom, trying to keep the flow as linear as possible. Avoid jumping back and forth in the program. First you need to arrange the major tasks to be achieved. Then try to break the major tasks into subtasks. These can be represented by functions or subprograms. They should accomplish limited tasks and as far as possible be independent of each other. That will allow you to use them in other programs as well.\n\n * Try always to find some cases where an analytical solution exists or where simple test cases can be applied. If possible, devise different algorithms for solving the same problem. If you get the same answers, you may have coded things correctly or made the same error twice or more.\n\n\n\n## Getting Started\n\n**Compiling and linking, without QTcreator.**\n\nIn order to obtain an executable file for a C++ program, the following\ninstructions under Linux/Unix can be used\n\n c++ -c -Wall myprogram.cpp\n c++ -o myprogram myprogram.o\n\n\nwhere the compiler is called through the command c++/g++. The compiler\noption -Wall means that a warning is issued in case of non-standard\nlanguage. The executable file is in this case `myprogram`. The option\n`-c` is for compilation only, where the program is translated into machine code,\nwhile the `-o` option links the produced object file `myprogram.o`\nand produces the executable `myprogram` .\n\nFor Fortran2008 we use the Intel compiler, replace `c++` with `ifort`.\nAlso, to speed up the code use compile options like\n\n c++ -O3 -c -Wall myprogram.cpp\n\n\n## Makefiles and simple scripts\n\nUnder Linux/Unix it is often convenient to create a\nso-called makefile, which is a script which includes possible\ncompiling commands.\n\n # Comment lines\n # General makefile for c - choose PROG = name of given program\n # Here we define compiler option, libraries and the target\n CC= g++ -Wall\n PROG= myprogram\n # this is the math library in C, not necessary for C++\n LIB = -lm\n # Here we make the executable file\n ${PROG} : ${PROG}.o\n ${CC} ${PROG}.o ${LIB} -o ${PROG}\n # whereas here we create the object file\n ${PROG}.o : ${PROG}.c\n ${CC} -c ${PROG}.c\n\n\nIf you name your file for `makefile`, simply type the command\n`make` and Linux/Unix executes all of the statements in the above\nmakefile. Note that C++ files have the extension `.cpp`.\n\n## [Hello world](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program1.cpp)\n\n**The C encounter.**\n\nHere we present first the C version.\n\n /* comments in C begin like this and end with */\n #include /* atof function */\n #include /* sine function */\n #include /* printf function */\n int main (int argc, char* argv[])\n {\n double r, s; /* declare variables */\n r = atof(argv[1]); /* convert the text argv[1] to double */\n s = sin(r);\n printf(\"Hello, World! sin(%g)=%g\\n\", r, s);\n return 0; /* success execution of the program */\n \n\n\n## Hello World, dissecting the code\n\n**Dissection I.**\n\nThe compiler must see a declaration of a function before you can\ncall it (the compiler checks the argument and return types).\nThe declaration of library functions appears\nin so-called \"header files\" that must be included in the program, e.g.,\n\n #include /* atof function */\n\n\nWe call three functions (atof, sin, printf)\nand these are declared in three different header files.\nThe main program is a function called main\nwith a return value set to an integer, int (0 if success).\nThe operating system stores the return value,\nand other programs/utilities can check whether\nthe execution was successful or not.\nThe command-line arguments are transferred to the main function through\n\n int main (int argc, char* argv[])\n\n\n## Hello World, more dissection\n\n**Dissection II.**\n\nThe command-line arguments are transferred to the main function through\n\n int main (int argc, char* argv[])\n\n\nThe integer `argc` is the no of command-line arguments, set to\none in our case, while\n`argv` is a vector of strings containing the command-line arguments\nwith `argv[0]` containing the name of the program\nand `argv[1]`, `argv[2]`, ... are the command-line args, i.e., the number of\nlines of input to the program.\nHere we define floating points, see also below,\nthrough the keywords `float` for single precision real numbers and\n`double` for double precision. The function\n`atof` transforms a text (`argv[1]`) to a float.\nThe sine function is declared in math.h, a library which\nis not automatically included and needs to be linked when computing\nan executable file.\n\nWith the command `printf` we obtain a formatted printout.\nThe `printf` syntax is used for formatting output\nin many C-inspired languages (Perl, Python, Awk, partly C++).\n\n\n\n## Hello World\n\n**Now in C++.**\n\nHere we present first the C++ version.\n\n // A comment line begins like this in C++ programs\n // Standard ANSI-C++ include files\n #include // input and output\n #include // math functions\n using namespace std;\n int main (int argc, char* argv[])\n {\n // convert the text argv[1] to double using atof:\n double r = atof(argv[1]); /* convert the text argv[1] to double */\n double s = sin(r);\n cout << \"Hello, World! sin(\" << r << \") =\" << s << endl;\n return 0; /* success execution of the program */\n }\n\n\n## C++ Hello World\n\n**Dissection I.**\n\nWe have replaced the call to `printf` with the standard C++ function\n`cout`. The header file `` is then needed.\nIn addition, we don't need to\ndeclare variables like `r` and `s` at the beginning of the program.\nI personally prefer\nhowever to declare all variables at the beginning of a function, as this\ngives *me* a feeling of greater readability.\n\n\n\n## Brief summary\n\n**C/C++ program.**\n\n * A C/C++ program begins with include statements of header files (libraries,intrinsic functions etc)\n\n * Functions which are used are normally defined at top (details next week)\n\n * The main program is set up as an integer, it returns 0 (everything correct) or 1 (something went wrong)\n\n * Standard `if`, `while` and `for` statements as in Java, Fortran, Python...\n\n * Integers have a very limited range.\n\n\n\n## Brief summary\n\n**Arrays.**\n\n * A C/C++ array begins by indexing at 0!\n\n * Array allocations are done by size, not by the final index value.If you allocate an array with 10 elements, you should index them from $0,1,\\dots, 9$.\n\n * Initialize always an array before a computation.\n\n\n\n## Serious problems and representation of numbers\n\n**Integer and Real Numbers.**\n\n\n * Overflow\n\n * Underflow\n\n * Roundoff errors\n\n * Loss of precision\n\n\n\n## Limits, you must declare variables\n\n\n**C++ and Fortran declarations.**\n\n\n\n\ntype in C/C++ and Fortran2008 bits range \n\n int/INTEGER (2) 16 -32768 to 32767 unsigned int 16 0 to 65535 signed int 16 -32768 to 32767 short int 16 -32768 to 32767 unsigned short int 16 0 to 65535 signed short int 16 $-32768$ to 32767 int/long int/INTEGER (4) 32 -2147483648 to 2147483647 signed long int 32 -2147483648 to 2147483647 float/REAL(4) 32 $3.4\\times 10^{-44}$ to $3.4\\times 10^{+38}$ double/REAL(8) 64 $1.7\\times 10^{-322}$ to $1.7\\times 10^{+308}$ long double 64 $1.7\\times 10^{-322}$ to $1.7\\times 10^{+308}$ \n
\n\n\n\n\n## From decimal to binary representation\n**How to do it.**\n\n$$\na_n2^n+a_{n-1}2^{n-1} +a_{n-2}2^{n-2} +\\dots +a_{0}2^{0}.\n$$\n\nIn binary notation we have thus $(417)_{10} =(110110001)_2$\nsince we have\n\n$$\n\\begin{align*}\n(110100001)_2\n&=1\\times2^8+1\\times 2^{7}+0\\times 2^{6}+1\\times 2^{5}+0\\times 2^{4}+0\\times 2^{3}\\\\\n&+0\\times 2^{2}+0\\times 2^{2}+0\\times 2^{1}+1\\times 2^{0}.\n\\end{align*}\n$$\n\n## From decimal to binary representation, the actual operation\nTo see this, we have performed the following divisions by 2\n\n\n\n 417/2=208 remainder 1 coefficient of $2^{0}$ is 1 208/2=104 remainder 0 coefficient of $2^{1}$ is 0 104/2=52 remainder 0 coefficient of $2^{2}$ is 0 52/2=26 remainder 0 coefficient of $2^{3}$ is 0 26/2=13 remainder 1 coefficient of $2^{4}$ is 0 13/2= 6 remainder 1 coefficient of $2^{5}$ is 1 6/2= 3 remainder 0 coefficient of $2^{6}$ is 0 3/2= 1 remainder 1 coefficient of $2^{7}$ is 1 1/2= 0 remainder 1 coefficient of $2^{8}$ is 1 \n
\n\n\n\n## [From decimal to binary representation](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program2.cpp)\n\n**Integer numbers.**\n\n #include \n #include \n #include \n #include \n using namespace std;\n int main (int argc, char* argv[])\n {\n int i; \n int terms[32]; // storage of a0, a1, etc, up to 32 bits\n int save;\n int number = atoi(argv[1]); \n save = number;\n // initialise the term a0, a1 etc\n for (i=0; i < 32 ; i++){ terms[i] = 0;}\n for (i=0; i < 32 ; i++){ \n terms[i] = number%2;\n number /= 2;\n }\n // write out results\n cout << \"Number of bytes used= \" << sizeof(number) << endl;\n for (i=0; i < 32 ; i++){ \n cout << \" Term nr: \" << i << \"Value= \" << terms[i];\n cout << endl;\n }\n return 0; \n }\n\n\n## [From decimal to binary representation](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/Fortran/program2.f90)\n\n**Integer numbers, Fortran.**\n\n PROGRAM binary_integer\n IMPLICIT NONE\n INTEGER i, number, terms(0:31) ! storage of a0, a1, etc, up to 32 bits\n \n WRITE(*,*) 'Give a number to transform to binary notation'\n READ(*,*) number\n ! Initialise the terms a0, a1 etc\n terms = 0\n ! Fortran takes only integer loop variables\n DO i=0, 31\n terms(i) = MOD(number,2)\n number = number/2\n ENDDO\n ! write out results\n WRITE(*,*) 'Binary representation '\n DO i=0, 31\n WRITE(*,*)' Term nr and value', i, terms(i)\n ENDDO\n \n END PROGRAM binary_integer\n\n\n## [Representing Integer Numbers](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program3.cpp)\n\n**Possible Overflow for Integers.**\n\n // A comment line begins like this in C++ programs\n // Program to calculate 2**n\n // Standard ANSI-C++ include files */\n #include \n #include \n using namespace std\n int main()\n {\n int int1, int2, int3;\n // print to screen\n cout << \"Read in the exponential N for 2^N =\" << endl;\n // read from screen\n cin >> int2;\n int1 = (int) pow(2., (double) int2);\n cout << \" 2^N * 2^N = \" << int1*int1 << endl;\n int3 = int1 - 1;\n cout << \" 2^N*(2^N - 1) = \" << int1 * int3 << endl;\n cout << \" 2^N- 1 = \" << int3 << endl;\n return 0;\n \n // End: program main()\n\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nIn the decimal system we would write a number like $9.90625$\nin what is called the normalized scientific notation.\n\n$$\n9.90625=0.990625\\times 10^{1},\n$$\n\nand a real non-zero number could be generalized as\n\n\n
\n\n$$\n\\begin{equation}\n x=\\pm r\\times 10^{{\\mbox{n}}},\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nwith $r$ a number in the range $1/10 \\le r < 1$.\nIn a similar way we can use represent a binary number in\nscientific notation as\n\n\n
\n\n$$\n\\begin{equation}\n x=\\pm q\\times 2^{{\\mbox{m}}},\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nwith $q$ a number in the range $1/2 \\le q < 1$.\nThis means that the mantissa of a binary number would be represented by\nthe general formula\n\n\n
\n\n$$\n\\begin{equation}\n(0.a_{-1}a_{-2}\\dots a_{-n})_2=a_{-1}\\times 2^{-1}\n+a_{-2}\\times 2^{-2}+\\dots+a_{-n}\\times 2^{-n}.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nIn a typical computer, floating-point numbers are represented\nin the way described above, but with certain restrictions\non $q$ and $m$ imposed by the available word length.\nIn the machine, our\nnumber $x$ is represented as\n\n\n
\n\n$$\n\\begin{equation}\n x=(-1)^s\\times {\\mbox{mantissa}}\\times 2^{{\\mbox{exponent}}},\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nwhere $s$ is the sign bit, and the exponent gives the available range.\nWith a single-precision word, 32 bits, 8 bits would typically be reserved\nfor the exponent, 1 bit for the sign and 23 for the mantissa.\n\n\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nA modification of the scientific notation for binary numbers is to\nrequire that the leading binary digit 1 appears to the left of the binary point.\nIn this case the representation of the mantissa $q$ would be\n$(1.f)_2$ and $ 1 \\le q < 2$. This form is rather useful when storing\nbinary numbers in a computer word, since we can always assume that the leading\nbit 1 is there. One bit of space can then be saved meaning that a 23 bits\nmantissa has actually 24 bits. This means explicitely that a binary number with 23 bits\nfor the mantissa reads\n\n\n
\n\n$$\n\\begin{equation}\n(1.a_{-1}a_{-2}\\dots a_{-23})_2=1\\times 2^0+a_{-1}\\times 2^{-1}+\n+a_{-2}\\times 2^{-2}+\\dots+a_{-23}\\times 2^{-23}.\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\n## Loss of Precision, example\nAs an example, consider the 32 bits binary number\n\n$$\n(10111110111101000000000000000000)_2,\n$$\n\nwhere the first bit is reserved for the sign, 1 in this case yielding a\nnegative sign. The exponent $m$ is given by the next 8 binary numbers\n$01111101$ resulting in 125 in the decimal system.\n\n\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nHowever, since the\nexponent has eight bits, this means it has $2^8-1=255$ possible numbers in the interval\n$-128 \\le m \\le 127$, our final\nexponent is $125-127=-2$ resulting in $2^{-2}$.\nInserting the sign and the mantissa yields the final number in the decimal representation as\n\n$$\n-2^{-2}\\left(1\\times 2^0+1\\times 2^{-1}+\n1\\times 2^{-2}+1\\times 2^{-3}+0\\times 2^{-4}+1\\times 2^{-5}\\right)=\n$$\n\n$$\n(-0.4765625)_{10}.\n$$\n\nIn this case we have an exact machine representation with 32 bits (actually, we need less than\n23 bits for the mantissa).\n\n\n\n## Loss of Precision, consequences\nIf our number $x$ can be exactly represented in the machine, we call\n$x$ a machine number. Unfortunately, most numbers cannot and are thereby\nonly approximated in the machine. When such a number occurs as the result\nof reading some input data or of a computation, an inevitable error\nwill arise in representing it as accurately as possible by\na machine number.\n\n\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nA floating number x, labelled $fl(x)$ will therefore always be represented as\n\n\n
\n\n$$\n\\begin{equation}\n fl(x) = x(1\\pm \\epsilon_x),\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\nwith $x$ the exact number and the error $|\\epsilon_x| \\le |\\epsilon_M|$, where\n$\\epsilon_M$ is the precision assigned. A number like $1/10$ has no exact binary representation\nwith single or double precision. Since the mantissa\n\n$$\n\\left(1.a_{-1}a_{-2}\\dots a_{-n}\\right)_2\n$$\n\nis always truncated at some stage $n$ due to its limited number of bits, there is only a\nlimited number of real binary numbers. The spacing between every real binary number is given by the\nchosen machine precision.\nFor a 32 bit words this number is approximately\n$ \\epsilon_M \\sim 10^{-7}$ and for double precision (64 bits) we have\n$ \\epsilon_M \\sim 10^{-16}$, or in terms of a binary base\nas $2^{-23}$ and $2^{-52}$ for single and double precision, respectively.\n\n\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nIn the machine a number is represented as\n\n\n
\n\n$$\n\\begin{equation}\n fl(x)= x(1+\\epsilon)\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nwhere $|\\epsilon| \\leq \\epsilon_M$ and $\\epsilon$ is given by the\nspecified precision, $10^{-7}$ for single and $10^{-16}$ for double\nprecision, respectively.\n$\\epsilon_M$ is the given precision.\nIn case of a subtraction $a=b-c$, we have\n\n\n
\n\n$$\n\\begin{equation}\n fl(a)=fl(b)-fl(c) = a(1+\\epsilon_a),\n\\label{_auto8} \\tag{8}\n\\end{equation}\n$$\n\nor\n\n\n
\n\n$$\n\\begin{equation}\n fl(a)=b(1+\\epsilon_b)-c(1+\\epsilon_c),\n\\label{_auto9} \\tag{9}\n\\end{equation}\n$$\n\n## Loss of Precision\nThe above means that\n\n\n
\n\n$$\n\\begin{equation}\n fl(a)/a=1+\\epsilon_b\\frac{b}{a}- \\epsilon_c\\frac{c}{a},\n\\label{_auto10} \\tag{10}\n\\end{equation}\n$$\n\nand if $b\\approx c$ we see that there is a potential for an increased\nerror in $fl(a)$.\n\n\n\n## Loss of Precision\n\n**Machine Numbers.**\n\nDefine\nthe absolute error as\n\n\n
\n\n$$\n\\begin{equation}\n |fl(a)-a|,\n\\label{_auto11} \\tag{11}\n\\end{equation}\n$$\n\nwhereas the relative error is\n\n\n
\n\n$$\n\\begin{equation}\n \\frac{ |fl(a)-a|}{a} \\le \\epsilon_a.\n\\label{_auto12} \\tag{12}\n\\end{equation}\n$$\n\n## Loss of Precision\nThe above subraction is thus\n\n\n
\n\n$$\n\\begin{equation}\n \\frac{ |fl(a)-a|}{a}=\\frac{ |fl(b)-fl(c)-(b-c)|}{a},\n\\label{_auto13} \\tag{13}\n\\end{equation}\n$$\n\nyielding\n\n\n
\n\n$$\n\\begin{equation}\n \\frac{ |fl(a)-a|}{a}=\\frac{ |b\\epsilon_b- c\\epsilon_c|}{a}.\n\\label{_auto14} \\tag{14}\n\\end{equation}\n$$\n\nThe relative error\nis the quantity of interest in scientific work. Information about the\nabsolute error is normally of little use in the absence of the magnitude\nof the quantity being measured.\n\n\n\n## Loss of numerical precision\n\nSuppose we wish to evaluate the function\n\n$$\nf(x)=\\frac{1-\\cos(x)}{\\sin(x)},\n$$\n\nfor small values of $x$. Five leading digits. If we multiply the denominator and numerator\nwith $1+\\cos(x)$ we obtain the equivalent expression\n\n$$\nf(x)=\\frac{\\sin(x)}{1+\\cos(x)}.\n$$\n\nIf we now choose $x=0.007$ (in radians) our choice of precision results in\n\n$$\n\\sin(0.007)\\approx 0.69999\\times 10^{-2},\n$$\n\nand\n\n$$\n\\cos(0.007)\\approx 0.99998.\n$$\n\n## Loss of numerical precision\n\nThe first expression for $f(x)$ results in\n\n$$\nf(x)=\\frac{1-0.99998}{0.69999\\times 10^{-2}}=\\frac{0.2\\times 10^{-4}}{0.69999\\times 10^{-2}}=0.28572\\times 10^{-2},\n$$\n\nwhile the second expression results in\n\n$$\nf(x)=\\frac{0.69999\\times 10^{-2}}{1+0.99998}=\n\\frac{0.69999\\times 10^{-2}}{1.99998}=0.35000\\times 10^{-2},\n$$\n\nwhich is also the exact result. In the first expression, due to our\nchoice of precision, we have\nonly one relevant digit in the numerator, after the\nsubtraction. This leads to a loss of precision and a wrong result due to\na cancellation of two nearly equal numbers.\nIf we had chosen a precision of six leading digits, both expressions\nyield the same answer.\n\n## Loss of numerical precision\n\nIf we were to evaluate $x\\sim \\pi$, then the second expression for $f(x)$\ncan lead to potential losses of precision due to cancellations of nearly\nequal numbers.\n\nThis simple example demonstrates the loss of numerical precision due\nto roundoff errors, where the number of leading digits is lost\nin a subtraction of two near equal numbers.\nThe lesson to be drawn is that we cannot blindly compute a function.\nWe will always need to carefully analyze our algorithm in the search for\npotential pitfalls. There is no magic recipe however, the only guideline\nis an understanding of the fact that a machine cannot represent\ncorrectly *all* numbers.\n\n## Loss of precision can cause serious problems\n\n**Real Numbers.**\n\n\n * **Overflow**: When the positive exponent exceeds the max value, e.g., 308 for `DOUBLE PRECISION` (64 bits). Under such circumstances the program will terminate and some compilers may give you the warning `OVERFLOW`.\n\n * **Underflow**: When the negative exponent becomes smaller than the min value, e.g., -308 for `DOUBLE PRECISION`. Normally, the variable is then set to zero and the program continues. Other compilers (or compiler options) may warn you with the `UNDERFLOW` message and the program terminates.\n\n\n\n## Loss of precision, real numbers\n\n\n\n### Roundoff errors\n\nA floating point number like\n\n\n
\n\n$$\n\\begin{equation}\n x= 1.234567891112131468 = 0.1234567891112131468\\times 10^{1}\n\\label{_auto15} \\tag{15}\n\\end{equation}\n$$\n\nmay be stored in the following way. The exponent is small\nand is stored in full precision. However,\nthe mantissa is not stored fully. In double precision (64 bits), digits\nbeyond the\n15th are lost since the mantissa is normally stored in two words,\none which is the most significant one representing\n123456 and the least significant one containing 789111213. The digits\nbeyond 3 are lost. Clearly, if we are summing alternating series\nwith large numbers, subtractions between two large numbers may lead\nto roundoff errors, since not all relevant digits are kept.\nThis leads eventually to the next problem, namely\n\n## More on loss of precision\n\n**Real Numbers.**\n\n\n * **Loss of precision**: When one has to e.g., multiply two large numbers where one suspects that the outcome may be beyond the bonds imposed by the variable declaration, one could represent the numbers by logarithms, or rewrite the equations to be solved in terms of dimensionless variables. When dealing with problems in e.g., particle physics or nuclear physics where distance is measured in fm ($10^{-15}$ m), it can be quite convenient to redefine the variables for distance in terms of a dimensionless variable of the order of unity. To give an example, suppose you work with single precision and wish to perform the addition $1+10^{-8}$. In this case, the information containing in $10^{-8}$ is simply lost in the addition. Typically, when performing the addition, the computer equates first the exponents of the two numbers to be added. For $10^{-8}$ this has however catastrophic consequences since in order to obtain an exponent equal to $10^0$, bits in the mantissa are shifted to the right. At the end, all bits in the mantissa are zeros.\n\n\n\n## A problematic case\n\n**Three ways of computing $e^{-x}$.**\n\nBrute force:\n\n$$\n\\exp{(-x)}=\\sum_{n=0}^{\\infty}(-1)^n\\frac{x^n}{n!}\n$$\n\nRecursion relation for\n\n$$\n\\exp{(-x)}=\\sum_{n=0}^{\\infty}s_n=\\sum_{n=0}^{\\infty}(-1)^n\\frac{x^n}{n!}\n$$\n\n$$\ns_n=-s_{n-1}\\frac{x}{n},\n$$\n\n$$\n\\exp{(x)}=\\sum_{n=0}^{\\infty}s_n\n$$\n\n$$\n\\exp{(-x)}=\\frac{1}{\\exp{(x)}}\n$$\n\n## [Program](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program4.cpp) to compute $\\exp{(-x)}$\n\n**Brute Force.**\n\n // Program to calculate function exp(-x)\n // using straightforward summation with differing precision\n using namespace std\n #include \n #include \n // type float: 32 bits precision\n // type double: 64 bits precision\n #define TYPE double\n #define PHASE(a) (1 - 2 * (abs(a) % 2))\n #define TRUNCATION 1.0E-10\n // function declaration\n TYPE factorial(int);\n\n\n## Program to compute $\\exp{(-x)}$\n\n**Still Brute Force.**\n\n int main()\n {\n int n;\n TYPE x, term, sum;\n for(x = 0.0; x < 100.0; x += 10.0) {\n sum = 0.0; //initialization\n n = 0;\n term = 1;\n while(fabs(term) > TRUNCATION) {\n term = PHASE(n) * (TYPE) pow((TYPE) x,(TYPE) n)\n / factorial(n);\n sum += term;\n n++;\n } // end of while() loop\n\n\n## Program to compute $\\exp{(-x)}$\n\n**Oh, it never ends!**\n\n printf(\"\\nx = %4.1f exp = %12.5E series = %12.5E\n number of terms = %d\",\n x, exp(-x), sum, n);\n } // end of for() loop\n \n printf(\"\\n\"); // a final line shift on output\n return 0;\n } // End: function main()\n // The function factorial()\n // calculates and returns n!\n TYPE factorial(int n)\n {\n int loop;\n TYPE fac;\n for(loop = 1, fac = 1.0; loop <= n; loop++) {\n fac *= loop;\n \n return fac;\n } // End: function factorial()\n\n\n## Results $\\exp{(-x)}$\n\n**What is going on?**\n\n\n\n\n $x$ $\\exp{(-x)}$ Series Number of terms in series \n\n 0.0 0.100000E+01 0.100000E+01 1 10.0 0.453999E-04 0.453999E-04 44 20.0 0.206115E-08 0.487460E-08 72 30.0 0.935762E-13 -0.342134E-04 100 40.0 0.424835E-17 -0.221033E+01 127 50.0 0.192875E-21 -0.833851E+05 155 60.0 0.875651E-26 -0.850381E+09 171 70.0 0.397545E-30 NaN 171 80.0 0.180485E-34 NaN 171 90.0 0.819401E-39 NaN 171 100.0 0.372008E-43 NaN 171 \n
\n\n\n\n\n## [Program](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program5.cpp) to compute $\\exp{(-x)}$\n\n // program to compute exp(-x) without exponentials\n using namespace std\n #include \n #include \n #define TRUNCATION 1.0E-10\n \n int main()\n {\n int loop, n;\n double x, term, sum;\n for(loop = 0; loop <= 100; loop += 10)\n {\n x = (double) loop; // initialization\n sum = 1.0;\n term = 1;\n n = 1;\n\n\n## Program to compute $\\exp{(-x)}$\n\n**Last statements.**\n\n while(fabs(term) > TRUNCATION)\n {\n \t term *= -x/((double) n);\n \t sum += term;\n \t n++;\n } // end while loop\n cout << \"x = \" << x << \" exp = \" << exp(-x) <<\"series = \"\n << sum << \" number of terms =\" << n << endl;\n } // end of for() loop\n \n cout << endl; // a final line shift on output\n \n } /* End: function main() */\n\n\n## Results $\\exp{(-x)}$\n\n**More Problems.**\n\n\n\n\n $x$ $\\exp{(-x)}$ Series Number of terms in series \n\n 0.000000 0.10000000E+01 0.10000000E+01 1 10.000000 0.45399900E-04 0.45399900E-04 44 20.000000 0.20611536E-08 0.56385075E-08 72 30.000000 0.93576230E-13 -0.30668111E-04 100 40.000000 0.42483543E-17 -0.31657319E+01 127 50.000000 0.19287498E-21 0.11072933E+05 155 60.000000 0.87565108E-26 -0.33516811E+09 182 70.000000 0.39754497E-30 -0.32979605E+14 209 80.000000 0.18048514E-34 0.91805682E+17 237 90.000000 0.81940126E-39 -0.50516254E+22 264 100.000000 0.37200760E-43 -0.29137556E+26 291 \n
\n\n\n\n## Most used formula for derivatives\n\n**3 point formulae.**\n\nFirst derivative ($f_0 = f(x_0)$, $f_{-h}=f(x_0-h)$ and $f_{+h}=f(x_0+h)$\n\n$$\n\\frac{f_h-f_{-h}}{2h}=f'_0+\\sum_{j=1}^{\\infty}\\frac{f_0^{(2j+1)}}{(2j+1)!}h^{2j}.\n$$\n\nSecond derivative\n\n$$\n\\frac{ f_h -2f_0 +f_{-h}}{h^2}=f_0''+2\\sum_{j=1}^{\\infty}\\frac{f_0^{(2j+2)}}{(2j+2)!}h^{2j}.\n$$\n\n## Error Analysis\n\n$$\n\\epsilon=log_{10}\\left(\\left|\\frac{f''_{\\mbox{computed}}-f''_{\\mbox{exact}}}\n {f''_{\\mbox{exact}}}\\right|\\right),\n$$\n\n$$\n\\epsilon_{\\mbox{tot}}=\\epsilon_{\\mbox{approx}}+\\epsilon_{\\mbox{ro}}.\n$$\n\nFor the computed second derivative we have\n\n$$\nf_0''=\\frac{ f_h -2f_0 +f_{-h}}{h^2}-2\\sum_{j=1}^{\\infty}\\frac{f_0^{(2j+2)}}{(2j+2)!}h^{2j},\n$$\n\nand the truncation or approximation error goes like\n\n$$\n\\epsilon_{\\mbox{approx}}\\approx \\frac{f_0^{(4)}}{12}h^{2}.\n$$\n\n## Error Analysis\n\nIf we were not to worry about loss of precision, we could in principle\nmake $h$ as small as possible.\nHowever, due to the computed expression in the above program example\n\n$$\nf_0''=\\frac{ f_h -2f_0 +f_{-h}}{h^2}=\\frac{ (f_h -f_0) +(f_{-h}-f_0)}{h^2},\n$$\n\nwe reach fairly quickly a limit for where loss of precision due to the subtraction\nof two nearly equal numbers becomes crucial.\n\nIf $(f_{\\pm h} -f_0)$ are very close, we have\n$(f_{\\pm h} -f_0)\\approx \\epsilon_M$, where $|\\epsilon_M|\\le 10^{-7}$ for single and\n$|\\epsilon_M|\\le 10^{-15}$ for double precision, respectively.\n\nWe have then\n\n$$\n\\left|f_0''\\right|=\n \\left|\\frac{ (f_h -f_0) +(f_{-h}-f_0)}{h^2}\\right|\\le \\frac{ 2 \\epsilon_M}{h^2}.\n$$\n\n## Error Analysis\n\nOur total error becomes\n\n\n
\n\n$$\n\\left|\\epsilon_{\\mbox{tot}}\\right|\\le \\frac{2 \\epsilon_M}{h^2} +\n \\frac{f_0^{(4)}}{12}h^{2}.\n\\label{eq:experror} \\tag{16}\n$$\n\nIt is then natural to ask which value of $h$ yields the smallest\ntotal error. Taking the derivative of $\\left|\\epsilon_{\\mbox{tot}}\\right|$\nwith respect to $h$ results in\n\n$$\nh= \\left(\\frac{ 24\\epsilon_M}{f_0^{(4)}}\\right)^{1/4}.\n$$\n\nWith double precision and $x=10$ we obtain\n\n$$\nh\\approx 10^{-4}.\n$$\n\nBeyond this value, it is essentially the loss of numerical precision\nwhich takes over.\n\n\n\n## Error Analysis\n\nDue to the subtractive cancellation in the expression\nfor $f''$ there is a pronounced detoriation in accuracy as $h$ is made smaller\nand smaller.\n\nIt is instructive in this analysis to rewrite the numerator of\nthe computed derivative as\n\n$$\n(f_h -f_0) +(f_{-h}-f_0)=(e^{x+h}-e^{x}) + (e^{x-h}-e^{x}),\n$$\n\nas\n\n$$\n(f_h -f_0) +(f_{-h}-f_0)=e^x(e^{h}+e^{-h}-2),\n$$\n\nsince it is the difference $(e^{h}+e^{-h}-2)$ which causes\nthe loss of precision.\n\n\n\n## Error Analysis\n\n\n\n\n$x$ $h=0.01$ $h=0.001$ $h=0.0001$ $h=0.0000001$ Exact \n\n 0.0 1.000008 1.000000 1.000000 1.010303 1.000000 1.0 2.718304 2.718282 2.718282 2.753353 2.718282 2.0 7.389118 7.389057 7.389056 7.283063 7.389056 3.0 20.085704 20.085539 20.085537 20.250467 20.085537 4.0 54.598605 54.598155 54.598151 54.711789 54.598150 5.0 148.414396 148.413172 148.413161 150.635056 148.413159 \n
\n\n\n\n## Error Analysis\n\nThe results for $x=10$ are shown in the Table\n\n\n\n $h$ $e^{h}+e^{-h}$ $e^{h}+e^{-h}-2$ \n\n $10^{-1}$ 2.0100083361116070 $1.0008336111607230\\times 10^{-2}$ $10^{-2}$ 2.0001000008333358 $1.0000083333605581\\times 10^{-4}$ $10^{-3}$ 2.0000010000000836 $1.0000000834065048\\times 10^{-6}$ $10^{-5}$ 2.0000000099999999 $1.0000000050247593\\times 10^{-8}$ $10^{-5}$ 2.0000000001000000 $9.9999897251734637\\times 10^{-11}$ $10^{-6}$ 2.0000000000010001 $9.9997787827987850\\times 10^{-13}$ $10^{-7}$ 2.0000000000000098 $9.9920072216264089\\times 10^{-15}$ $10^{-8}$ 2.0000000000000000 $0.0000000000000000\\times 10^{0}$ $10^{-9}$ 2.0000000000000000 $1.1102230246251565\\times 10^{-16}$ $10^{-10}$ 2.0000000000000000 $0.0000000000000000\\times 10^{0}$ \n
\n\n\n\n## Technical Matter in C/C++: Pointers\n\nA pointer specifies where a value resides in the computer's memory (like a house number specifies where a particular family resides on a street).\n\nA pointer points to an address not to a data container of any kind!\n\nSimple example declarations:\n\n using namespace std; // note use of namespace\n int main()\n {\n // what are the differences?\n int var;\n cin >> var;\n int *p, q;\n int *s, *t;\n int * a new[var]; // dynamic memory allocation\n delete [] a;\n }\n\n\n## Technical Matter in C/C++: [Pointer example I](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program7.cpp)\n\n using namespace std; // note use of namespace\n int main()\n {\n int var;\n int *p;\n p = &var;\n var = 421;\n printf(\"Address of integer variable var : %p\\n\",&var);\n printf(\"Its value: %d\\n\", var);\n printf(\"Value of integer pointer p : %p\\n\",p);\n printf(\"The value p points at : %d\\n\",*p);\n printf(\"Address of the pointer p : %p\\n\",&p);\n return 0;\n }\n\n\n## Dissection: Pointer example I\n\n**Discussion.**\n\n int main()\n {\n int var; // Define an integer variable var\n int *p; // Define a pointer to an integer\n p = &var; // Extract the address of var\n var = 421; // Change content of var\n printf(\"Address of integer variable var : %p\\n\", &var);\n printf(\"Its value: %d\\n\", var); // 421\n printf(\"Value of integer pointer p : %p\\n\", p); // = &var\n // The content of the variable pointed to by p is *p\n printf(\"The value p points at : %d\\n\", *p);\n // Address where the pointer is stored in memory\n printf(\"Address of the pointer p : %p\\n\", &p);\n return 0;\n }\n\n\n## [Pointer example II](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/IntroProgramming/cpp/program8.cpp)\n\n int matr[2];\n int *p;\n p = &matr[0];\n matr[0] = 321;\n matr[1] = 322;\n printf(\"\\nAddress of matrix element matr[1]: %p\",&matr[0]);\n printf(\"\\nValue of the matrix element matr[1]; %d\",matr[0]);\n printf(\"\\nAddress of matrix element matr[2]: %p\",&matr[1]);\n printf(\"\\nValue of the matrix element matr[2]: %d\\n\", matr[1]);\n printf(\"\\nValue of the pointer p: %p\",p);\n printf(\"\\nThe value p points to: %d\",*p);\n printf(\"\\nThe value that (p+1) points to %d\\n\",*(p+1));\n printf(\"\\nAddress of pointer p : %p\\n\",&p);\n\n\n## Dissection: Pointer example II\n\n int matr[2]; // Define integer array with two elements\n int *p; // Define pointer to integer\n p = &matr[0]; // Point to the address of the first element in matr\n matr[0] = 321; // Change the first element\n matr[1] = 322; // Change the second element\n printf(\"\\nAddress of matrix element matr[1]: %p\", &matr[0]);\n printf(\"\\nValue of the matrix element matr[1]; %d\", matr[0]);\n printf(\"\\nAddress of matrix element matr[2]: %p\", &matr[1]);\n printf(\"\\nValue of the matrix element matr[2]: %d\\n\", matr[1]);\n printf(\"\\nValue of the pointer p: %p\", p);\n printf(\"\\nThe value p points to: %d\", *p);\n printf(\"\\nThe value that (p+1) points to %d\\n\", *(p+1));\n printf(\"\\nAddress of pointer p : %p\\n\", &p);\n\n\n## Output of Pointer example II\n\n Address of the matrix element matr[1]: 0xbfffef70\n Value of the matrix element matr[1]; 321\n Address of the matrix element matr[2]: 0xbfffef74\n Value of the matrix element matr[2]: 322\n Value of the pointer: 0xbfffef70\n The value pointer points at: 321\n The value that (pointer+1) points at: 322\n Address of the pointer variable : 0xbfffef6c\n\n\n## File handling; C-way\n\n using namespace std;\n #include \n int main(int argc, char *argv[])\n {\n FILE *in_file, *out_file;\n if( argc < 3) {\n printf(\"The programs has the following structure :\\n\");\n printf(\"write in the name of the input and output files \\n\");\n exit(0);\n }\n in_file = fopen( argv[1], \"r\");// returns pointer to the input file\n if( in_file == NULL ) { // NULL means that the file is missing\n printf(\"Can't find the input file %s\\n\", argv[1]);\n exit(0);\n\n\n## File handling; C way cont.\n\n out_file = fopen( argv[2], \"w\"); // returns a pointer to the output file\n if( out_file == NULL ) { // can't find the file\n printf(\"Can't find the output file%s\\n\", argv[2]);\n exit(0);\n }\n fclose(in_file);\n fclose(out_file);\n return 0;\n\n\n## File handling, C++-way\n\n #include \n \n // input and output file as global variable\n ofstream ofile;\n ifstream ifile;\n\n\n## File handling, C++-way\n\n int main(int argc, char* argv[])\n {\n char *outfilename;\n //Read in output file, abort if there are too\n //few command-line arguments\n if( argc <= 1 ){\n cout << \"Bad Usage: \" << argv[0] <<\n \" read also output file on same line\" << endl;\n exit(1);\n }\n else{\n outfilename=argv[1];\n }\n ofile.open(outfilename);\n .....\n ofile.close(); // close output file\n\n\n## File handling, C++-way\n\n void output(double r_min , double r_max, int max_step,\n double *d)\n {\n int i;\n ofile << \"RESULTS:\" << endl;\n ofile << setiosflags(ios::showpoint | ios::uppercase);\n ofile <<\"R_min = \" << setw(15) << setprecision(8) <> a >> b >> c; // skips white space in between\n \n // Can test on success of reading:\n \n if (!(ifile >> a >> b >> c)) ok = 0;\n\n\n## Call by value or reference\nC++ allows the programmer to use solely call by reference (note that call by reference is implemented as pointers). To see the difference between C and C++, consider the following simple examples.\nIn C we would write\n\n int n; n =8;\n func(&n); /* &n is a pointer to n */\n ....\n void func(int *i)\n {\n *i = 10; /* n is changed to 10 */\n ....\n }\n\n\nwhereas in C++ we would write\n\n int n; n =8;\n func(n); // just transfer n itself\n ....\n void func(int& i)\n {\n i = 10; // n is changed to 10\n ....\n }\n\n\n## Call by value or reference\nThe reason why we emphasize the difference between call by value and call\nby reference is that it allows the programmer to avoid pitfalls\nlike unwanted changes of variables. However, many people feel that this\nreduces the readability of the code.\n\n\n## Call by value and reference, F90/95\n\nIn Fortran we can use `INTENT(IN)`, `INTENT(OUT)`, `INTENT(INOUT)` to let the\nprogram know which values should or should not be changed.\n\n SUBROUTINE coulomb_integral(np,lp,n,l,coulomb)\n USE effective_interaction_declar\n USE energy_variables\n USE wave_functions\n IMPLICIT NONE\n INTEGER, INTENT(IN) :: n, l, np, lp\n INTEGER :: i\n REAL(KIND=8), INTENT(INOUT) :: coulomb\n REAL(KIND=8) :: z_rel, oscl_r, sum_coulomb\n ...\n\n\nThis hinders unwanted changes and increases readability.\n\n\n## [Example codes in c++, dynamic memory allocation](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/Classes/cpp/program4.cpp)\n\n #include \n #include \n using namespace std; // note use of namespace \n int main (int argc, char* argv[])\n {\n int i = atoi(argv[1]); \n // Dynamic memory allocation: need tp declare -a- as a pointer\n // You can use double *a = new double[i]; or \n double *a;\n a = new double[i];\n // the first of element of a, a[0], and its address is the \n // value of the pointer. \n /* This is a longer comment\n if we want a static memory allocation \n this is the way to do it\n */\n cout << \" bytes for i=\" << sizeof(i) << endl;\n for (int j = 0; j < i; j++) {\n a[j] = j*exp(2.0);\n cout << \"a=\" << a[j] << endl;\n }\n // freeing memory\n delete [] a;\n // to check for memory leaks, use the software called -valgrind-\n return 0; /* success execution of the program */\n }\n \n\n\n## [Example codes in c++, writing to file and dynamic allocation for arrays](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/Classes/cpp/program5.cpp)\n\n #include \n #include \n #include \n #include \n using namespace std; // note use of namespace \n \n // output file as global variable\n \n ofstream ofile; \n \n // Begin of main program \n \n int main(int argc, char* argv[])\n {\n char *outfilename;\n // Read in output file, abort if there are too few command-line arguments\n if( argc <= 2 ){\n cout << \"Bad Usage: \" << argv[0] << \n \" read also output file and number of elements on same line\" << endl;\n exit(1);\n }\n else{\n outfilename=argv[1];\n }\n \n // opening a file for the program\n ofile.open(outfilename); \n int i = atoi(argv[2]); \n // int *a;\n //a = new int[i];\n double *a = new double[i]; \n cout << \" bytes for i=\" << sizeof(i) << endl;\n for (int j = 0; j < i; j++) {\n a[j] = j*exp(2.0);\n // ofile instead of cout\n ofile << setw(15) << setprecision(8) << \"a=\" << a[j] << endl;\n }\n delete [] a; // free memory\n ofile.close(); // close output file\n return 0;\n }\n \n\n\n## [Example codes in c++, transfer of data using call by value and call by reference](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/Classes/cpp/program6.cpp)\n\n #include \n using namespace std;\n // Declare functions before main\n void func(int, int*);\n int main(int argc, char *argv[]) \n {\n int a; \n int *b;\n a = 10;\n b = new int[10];\n for(int i = 0; i < 10; i++) {\n b[i] = i;\n cout << b[i] << endl;\n }\n // the variable a is transferred by call by value. This means\n // that the function func cannot change a in the calling function\n func( a,b);\n \n delete [] b ; \n return 0;\n } // End: function main()\n \n void func( int x, int *y) \n {\n // a becomes locally x and it can be changed locally\n x+=7;\n // func gets the address of the first element of y (b)\n // it changes y[0] to 10 and when returning control to main\n // it changes also b[0]. Call by reference\n *y += 10; // *y = *y+10;\n // explicit element \n y[6] += 10;\n // in this function y[0] and y[6] have been changed and when returning \n // control to main this means that b[0] and b[6] are changed. \n return;\n } // End: function func()\n \n\n\n## [Example codes in c++, operating on several arrays and printing time used](https://github.com/CompPhysics/ComputationalPhysicsMSU/blob/master/doc/Programs/LecturePrograms/programs/Classes/cpp/program7.cpp)\n\n #include \n #include \n #include \n #include \n #include \"time.h\" \n \n using namespace std; // note use of namespace \n int main (int argc, char* argv[])\n {\n int i = atoi(argv[1]); \n double *a, *b, *c;\n a = new double[i]; \n b = new double[i]; \n c = new double[i]; \n \n clock_t start, finish;\n start = clock();\n for (int j = 0; j < i; j++) {\n a[j] = cos(j*1.0);\n b[j] = sin(j+3.0);\n c[j] = 0.0;\n }\n for (int j = 0; j < i; j++) {\n c[j] = a[j]+b[j];\n }\n finish = clock();\n double timeused = (double) (finish - start)/(CLOCKS_PER_SEC );\n cout << setiosflags(ios::showpoint | ios::uppercase);\n cout << setprecision(10) << setw(20) << \"Time used for vector addition=\" << timeused << endl;\n delete [] a;\n delete [] b;\n delete [] c;\n return 0; /* success execution of the program */\n }\n \n\n", "meta": {"hexsha": "ceeb6733018d9e10923faee6ae4b48ea4bf897fc", "size": 82237, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/languages/ipynb/languages.ipynb", "max_stars_repo_name": "tiffanmc/compphys", "max_stars_repo_head_hexsha": "f37ebc905878d6b8cc5c597604d5523850df52d8", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/pub/languages/ipynb/languages.ipynb", "max_issues_repo_name": "tiffanmc/compphys", "max_issues_repo_head_hexsha": "f37ebc905878d6b8cc5c597604d5523850df52d8", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/pub/languages/ipynb/languages.ipynb", "max_forks_repo_name": "tiffanmc/compphys", "max_forks_repo_head_hexsha": "f37ebc905878d6b8cc5c597604d5523850df52d8", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.9053480475, "max_line_length": 1061, "alphanum_fraction": 0.4831766723, "converted": true, "num_tokens": 16408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. YES", "lm_q1_score": 0.28776780354463427, "lm_q2_score": 0.5117166047041654, "lm_q1q2_score": 0.14725556337303553}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ntag = HTML('''\nToggle cell visibility here .''')\ndisplay(tag)\n```\n\n\n\nToggle cell visibility here .\n\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport control as control\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\nfrom ipywidgets import widgets\nfrom ipywidgets import interact\nimport scipy.signal as signal\nimport sympy as sym\n\n```\n\n## Mehanski sistemi\n\n#### Model mase, vzmeti in dušilke\n> Model masa-vzmet-dušilka v splošnem sestoji iz ločenih vozlišč mas, razporejenih po celotnem sistemu in medsebojno povezanih z vzmetmi in dušilkami. Model se uporablja za modeliranje sistemov s kompleksnimi lastnostmi, kot sta nelinearnost in viskoelastičnost (vir: [Wikipedia](https://en.wikipedia.org/wiki/Mass-spring-damper_model \"Mass-spring-model\"))\n#### Četrtinski model avtomobila\n> Četrtinski model avtomobila se uporablja za analizo kakovosti vožnje pri uporabi različnih sistemov vzmetenja avtomobilob. Masa $m_1$ je ti. obremenjena masa, ki predstavlja eno četrtino mase avtomobila in jo podpira sistem vzmetenja. Masa $m_2$ predstavlja ti. neobremenjeno maso, tj. skupno maso kolesa in polosnega sklopa ter blažilnika z vzmetenjem. Togost in dušenje sistema za vzmetenja sta modelirana z idealno konstanto vzmeti $k_1$ in koeficientom dušenja $B$. Togost pnevmatike je modelirana s konstanto vzmeti $k_2$. (vir: [Chegg Study](https://www.chegg.com/homework-help/questions-and-answers/figure-p230-shows-1-4-car-model-used-analyze-ride-quality-automotive-suspension-systems-ma-q26244005 \"1/4 car model\"))\n\n---\n\n### Kako upravljati s tem interaktivnim primerom?\n\n1. Preklapljaš lahko med sistemoma *masa-vzmet-dušilka* in *četritnski model avtomobila* z izbiro ustreznega gumba.\n2. Za vhodno funkcijo $F$ lahko izbiraš med *koračno funkcijo*, *impulzno funkcijo*, *rampo* in *sinusno funkcijo. \n3. S premikanjem drsnikov lahko spreminjaš vrednosti mas ($m$; $m_1$ and $m_2$), koeficientov vzmeti ($k$; $k_1$ and $k_2$), koeficientov dušenja ($B$), ojačanje vstopnega signala in začetne pogoje ($x_0$, $\\dot{x}_0$, $y_0$, $\\dot{y}_0$).\n\n\n\n\n \n Masa-vzmet-dušilka \n Četrtinski model avtomobila \n \n \n \n \n \n
\n\n\n```python\n# create figure\nfig = plt.figure(figsize=(9.8, 4),num='Mehanski sistemi')\n\n# add sublot\nax = fig.add_subplot(111)\nax.set_title('Časovni odziv')\nax.set_ylabel('vhod, izhod')\nax.set_xlabel('$t$ [s]')\n\nax.grid(which='both', axis='both', color='lightgray')\n\ninputf, = ax.plot([], [])\nresponsef, = ax.plot([], [])\nresponsef2, = ax.plot([], [])\narrowf, = ax.plot([],[])\n\nstyle = {'description_width': 'initial','button_width':'180px'}\n\nselectSystem=widgets.ToggleButtons(\n options=[('masa-vzmet-dušilka',0),('četrtinski model avtomobila',1)],\n description='Izberi sistem: ', style=style) # define toggle buttons\nselectForce = widgets.ToggleButtons(\n options=[('koračna funkcija', 0), ('impulzna funkcija', 1), ('rampa', 2), ('sinusna funkcija', 3)],\n description='Izberi $F$: ', style=style)\ndisplay(selectSystem)\ndisplay(selectForce)\n\ndef build_model(M,K,B,M1,M2,B1,K1,K2,amp,x0,xpika0,y0,ypika0,select_System,index):\n \n num_of_samples = 1000\n total_time = 25\n t = np.linspace(0, total_time, num_of_samples) # time for which response is calculated (start, stop, step)\n \n global inputf, responsef, responsef2, arrowf\n \n if select_System==0:\n \n system0 = control.TransferFunction([1], [M, B, K])\n \n if index==0:\n inputfunc = np.ones(len(t))*amp\n inputfunc[0]=0\n time, response, xx = control.forced_response(system0, t, inputfunc, X0=[xpika0,x0]) \n \n elif index==1:\n inputfunc=signal.unit_impulse(1000, 0)*amp\n time, response, xx = control.forced_response(system0, t, inputfunc, X0=[xpika0,x0]) \n \n elif index==2:\n inputfunc=t;\n time, response, xx = control.forced_response(system0, t, inputfunc, X0=[xpika0,x0]) \n \n elif index==3:\n inputfunc=np.sin(t)*amp\n time, response, xx = control.forced_response(system0, t, inputfunc, X0=[xpika0,x0]) \n \n elif select_System==1:\n \n system1=control.TransferFunction([M2, B1, K1+K2], [M1*M2, M1*B1+M2*B1, M2*K1+M1*(K1+K2), K2*B1, K1*K2])\n system2=control.TransferFunction([B1*K1*M2**2, B1**2*K1*M2, B1*K1**2*M2 + 2*B1*K1*K2*M2,\n B1**2*K1*K2, B1*K1**2*K2 + B1*K1*K2**2],\n [M1**2*M2**2, B1*M1**2*M2 + 2*B1*M1*M2**2, \n B1**2*M1*M2 + B1**2*M2**2 + K1*M1**2*M2 + 2*K1*M1*M2**2 + 2*K2*M1**2*M2 + K2*M1*M2**2,\n 2*B1*K1*M1*M2 + 2*B1*K1*M2**2 + B1*K2*M1**2 + 5*B1*K2*M1*M2 + B1*K2*M2**2,\n B1**2*K2*M1 + 2*B1**2*K2*M2 + K1**2*M1*M2 + K1**2*M2**2 + K1*K2*M1**2 + 5*K1*K2*M1*M2 + K1*K2*M2**2 + K2**2*M1**2 + 2*K2**2*M1*M2,\n 2*B1*K1*K2*M1 + 4*B1*K1*K2*M2 + 3*B1*K2**2*M1 + 2*B1*K2**2*M2,\n B1**2*K2**2 + K1**2*K2*M1 + 2*K1**2*K2*M2 + 3*K1*K2**2*M1 + 2*K1*K2**2*M2 + K2**3*M1,\n 2*B1*K1*K2**2 + B1*K2**3,\n K1**2*K2**2 + K1*K2**3])\n if index==0:\n inputfunc = np.ones(len(t))*amp\n inputfunc[0]=0 \n time, response, xx = control.forced_response(system1, t, inputfunc, X0=[0,0,xpika0,x0])\n time2, response2, xx2 = control.forced_response(system2, t, inputfunc, X0=[0,0,0,0,0,0,ypika0,y0])\n \n elif index==1:\n inputfunc=signal.unit_impulse(1000, 0)*amp\n time, response, xx = control.forced_response(system1, t, inputfunc, X0=[0,0,xpika0,x0])\n time2, response2, xx2 = control.forced_response(system2, t, inputfunc, X0=[0,0,0,0,0,0,ypika0,y0])\n \n elif index==2:\n inputfunc=t;\n time, response, xx = control.forced_response(system1, t, inputfunc, X0=[0,0,xpika0,x0])\n time2, response2, xx2 = control.forced_response(system2, t, inputfunc, X0=[0,0,0,0,0,0,ypika0,y0])\n \n elif index==3:\n inputfunc=np.sin(t)*amp\n time, response, xx = control.forced_response(system1, t, inputfunc, X0=[0,0,xpika0,x0])\n time2, response2, xx2 = control.forced_response(system2, t, inputfunc, X0=[0,0,0,0,0,0,ypika0,y0])\n\n \n ax.lines.remove(responsef)\n ax.lines.remove(inputf)\n ax.lines.remove(responsef2)\n ax.lines.remove(arrowf)\n \n inputf, = ax.plot(t,inputfunc,label='$F$',color='C0')\n responsef, = ax.plot(time, response,label='$x$',color='C3')\n \n if select_System==1:\n responsef2, = ax.plot(time, response2,label='$y$',color='C2')\n elif select_System==0:\n responsef2, = ax.plot([],[])\n \n if index==1:\n if amp>0:\n arrowf, = ax.plot([-0.1,0,0.1],[amp-((amp*0.05)/2),amp,amp-((amp*0.05)/2)],color='C0',linewidth=4)\n elif amp==0:\n arrowf, = ax.plot([],[])\n elif amp<0:\n arrowf, = ax.plot([-0.1,0,0.1],[amp-((amp*0.05)/2),amp,amp-(amp*(0.05)/2)],color='C0',linewidth=4)\n else:\n arrowf, = ax.plot([],[])\n \n ax.relim()\n ax.autoscale_view()\n \n ax.legend() \n \ndef update_sliders(index):\n global m1_slider, b1_slider, k1_slider, m21_slider, m22_slider, b2_slider, k21_slider, k22_slider\n global x0_slider, xpika0_slider, y0_slider, ypika0_slider\n\n m1val = [0.1,0.1,0.1,0.1]\n k1val = [1,1,1,1]\n b1val = [0.1,0.1,0.1,0.1]\n m21val = [0.1,0.1,0.1,0.1]\n m22val = [0.1,0.1,0.1,0.1]\n b2val = [0.1,0.1,0.1,0.1]\n k21val = [1,1,1,1]\n k22val = [1,1,1,1]\n x0val = [0,0,0,0]\n xpika0val = [0,0,0,0]\n y0val = [0,0,0,0]\n ypika0val = [0,0,0,0]\n \n m1_slider.value = m1val[index]\n k1_slider.value = k1val[index]\n b1_slider.value = b1val[index]\n m21_slider.value = m21val[index]\n m22_slider.value = m22val[index]\n b2_slider.value = b2val[index]\n k21_slider.value = k21val[index]\n k22_slider.value = k22val[index]\n x0_slider.value = x0val[index]\n xpika0_slider.value = xpika0val[index]\n y0_slider.value = y0val[index]\n ypika0_slider.value = ypika0val[index] \n \ndef draw_controllers(type_select,index):\n \n global m1_slider, b1_slider, k1_slider, m21_slider, m22_slider, b2_slider, k21_slider, k22_slider\n global x0_slider, xpika0_slider, y0_slider, ypika0_slider\n \n \n x0_slider=widgets.FloatSlider(value=0, min=-1, max=1., step=.1,\n description='$x_0$ [dm]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n xpika0_slider=widgets.FloatSlider(value=0, min=-1, max=1., step=.1,\n description='${\\dot{x}}_0$ [dm/s]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n \n if type_select==0:\n \n amp_slider = widgets.FloatSlider(value=1.,min=-2.,max=2.,step=0.1,\n description='ojačanje vstopnega signala:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.1f',style=style)\n \n m1_slider = widgets.FloatSlider(value=.1, min=.01, max=1., step=.01,\n description='$m$ [kg]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n k1_slider = widgets.FloatSlider(value=1.,min=0.,max=20.,step=.1,\n description='$k$ [N/m]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.1f',)\n b1_slider = widgets.FloatSlider(value=.1,min=0.0,max=0.5,step=.01,\n description='$B$ [Ns/m]:',disabled=False,continuous_update=False,\n rientation='horizontal',readout=True,readout_format='.2f',)\n m21_slider = widgets.FloatSlider(value=.1,min=.01,max=1.,step=.01,\n description='$m_1$ [kg]:',disabled=True,continuous_update=False,orientation='horizontal',readout=True,readout_format='.2f',\n )\n m22_slider = widgets.FloatSlider(value=.1,min=.0,max=1.,step=.01,\n description='$m_2$ [kg]:',disabled=True,continuous_update=False,orientation='horizontal',readout=True,readout_format='.2f',\n )\n b2_slider = widgets.FloatSlider(value=.1,min=0.0,max=2,step=.01,\n description='$B$ [Ns/m]:',disabled=True,continuous_update=False,orientation='horizontal',readout=True,readout_format='.2f',\n )\n k21_slider = widgets.FloatSlider(value=1.,min=0.,max=20.,step=.1,\n description='$k_1$ [N/m]:',disabled=True,continuous_update=False,orientation='horizontal',readout=True,readout_format='.1f',\n )\n k22_slider = widgets.FloatSlider(value=1.,min=0.,max=20.,step=.1,\n description='$k_2$ [N/m]:',disabled=True,continuous_update=False,orientation='horizontal',readout=True,readout_format='.1f',\n )\n \n y0_slider=widgets.FloatSlider(value=0, min=-1, max=1., step=.1,\n description='$y_0$ [dm]:',disabled=True,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n ypika0_slider=widgets.FloatSlider(value=0, min=-1, max=1., step=.1,\n description='${\\dot{y}}_0$ [dm/s]:',disabled=True,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n elif type_select==1:\n \n amp_slider = widgets.FloatSlider(value=1.,min=-2.,max=2.,step=0.1,\n description='ojačanje vstopnega signala:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.1f',style=style)\n \n m1_slider = widgets.FloatSlider(value=.1, min=.01, max=1., step=.01,\n description='$m$ [kg]:',disabled=True,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n k1_slider = widgets.FloatSlider(value=1.,min=0.,max=20.,step=.1,\n description='$k$ [N/m]:',disabled=True,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.1f',)\n b1_slider = widgets.FloatSlider(value=.1,min=0.0,max=0.5,step=.01,\n description='$B$ [Ns/m]:',disabled=True,continuous_update=False,\n rientation='horizontal',readout=True,readout_format='.2f',)\n m21_slider = widgets.FloatSlider(value=.1,min=.01,max=1.,step=.01,\n description='$m_1$ [kg]:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.2f',\n )\n m22_slider = widgets.FloatSlider(value=.1,min=.0,max=1.,step=.01,\n description='$m_2$ [kg]:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.2f',\n )\n b2_slider = widgets.FloatSlider(value=.1,min=0.0,max=2,step=.01,\n description='$B$ [Ns/m]:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.2f',\n )\n k21_slider = widgets.FloatSlider(value=1.,min=0.,max=20.,step=.1,\n description='$k_1$ [N/m]:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.1f',\n )\n k22_slider = widgets.FloatSlider(value=1.,min=0.,max=20.,step=.1,\n description='$k_2$ [N/m]:',disabled=False,continuous_update=False,orientation='horizontal',readout=True,readout_format='.1f',\n )\n \n y0_slider=widgets.FloatSlider(value=0, min=-1, max=1., step=.1,\n description='$y_0$ [dm]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n ypika0_slider=widgets.FloatSlider(value=0, min=-1, max=1., step=.1,\n description='${\\dot{y}}_0$ [dm/s]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',) \n input_data = widgets.interactive_output(build_model, {'M':m1_slider, 'K':k1_slider, 'B':b1_slider, 'M1':m21_slider,\n 'M2':m22_slider, 'B1':b2_slider, 'K1':k21_slider, 'K2':k22_slider, 'amp':amp_slider,\n 'x0':x0_slider,'xpika0':xpika0_slider,'y0':y0_slider,'ypika0':ypika0_slider, \n 'select_System':selectSystem,'index':selectForce}) \n \n input_data2 = widgets.interactive_output(update_sliders, {'index':selectForce})\n \n box_layout = widgets.Layout(border='1px solid black',\n width='auto',\n height='',\n flex_flow='row',\n display='flex')\n\n buttons1=widgets.HBox([widgets.VBox([amp_slider],layout=widgets.Layout(width='auto')),\n widgets.VBox([x0_slider,xpika0_slider]),\n widgets.VBox([y0_slider,ypika0_slider])],layout=box_layout)\n display(widgets.VBox([widgets.Label('Izberi vrednosti ojačanja vstopnega signala in začetnih pogojev:'), buttons1]))\n display(widgets.HBox([widgets.VBox([m1_slider,k1_slider,b1_slider], layout=widgets.Layout(width='45%')),\n widgets.VBox([m21_slider,m22_slider,k21_slider,k22_slider,b2_slider], layout=widgets.Layout(width='45%'))]), input_data)\n \nwidgets.interactive_output(draw_controllers, {'type_select':selectSystem,'index':selectForce})\n```\n\n\n \n\n\n\n\n\n\n\n ToggleButtons(description='Izberi sistem: ', options=(('masa-vzmet-dušilka', 0), ('četrtinski model avtomobila…\n\n\n\n ToggleButtons(description='Izberi $F$: ', options=(('koračna funkcija', 0), ('impulzna funkcija', 1), ('rampa'…\n\n\n\n Output()\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "fed55cf3d5382ef5c554d00c5eb677cfae3e527f", "size": 141807, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_si/examples/02/TD-03-Mehanski_sistemi.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_si/examples/02/.ipynb_checkpoints/TD-03-Mehanski_sistemi-checkpoint.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_si/examples/02/.ipynb_checkpoints/TD-03-Mehanski_sistemi-checkpoint.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 113.4456, "max_line_length": 82627, "alphanum_fraction": 0.7729237626, "converted": true, "num_tokens": 5484, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.3007455726738824, "lm_q1q2_score": 0.14684906934539352}}
{"text": "```python\n%matplotlib inline\n```\n\n\nWord Embeddings: Encoding Lexical Semantics\n===========================================\n\nWord embeddings are dense vectors of real numbers, one per word in your\nvocabulary. In NLP, it is almost always the case that your features are\nwords! But how should you represent a word in a computer? You could\nstore its ascii character representation, but that only tells you what\nthe word *is*, it doesn't say much about what it *means* (you might be\nable to derive its part of speech from its affixes, or properties from\nits capitalization, but not much). Even more, in what sense could you\ncombine these representations? We often want dense outputs from our\nneural networks, where the inputs are $|V|$ dimensional, where\n$V$ is our vocabulary, but often the outputs are only a few\ndimensional (if we are only predicting a handful of labels, for\ninstance). How do we get from a massive dimensional space to a smaller\ndimensional space?\n\nHow about instead of ascii representations, we use a one-hot encoding?\nThat is, we represent the word $w$ by\n\n\\begin{align}\\overbrace{\\left[ 0, 0, \\dots, 1, \\dots, 0, 0 \\right]}^\\text{|V| elements}\\end{align}\n\nwhere the 1 is in a location unique to $w$. Any other word will\nhave a 1 in some other location, and a 0 everywhere else.\n\nThere is an enormous drawback to this representation, besides just how\nhuge it is. It basically treats all words as independent entities with\nno relation to each other. What we really want is some notion of\n*similarity* between words. Why? Let's see an example.\n\nSuppose we are building a language model. Suppose we have seen the\nsentences\n\n* The mathematician ran to the store.\n* The physicist ran to the store.\n* The mathematician solved the open problem.\n\nin our training data. Now suppose we get a new sentence never before\nseen in our training data:\n\n* The physicist solved the open problem.\n\nOur language model might do OK on this sentence, but wouldn't it be much\nbetter if we could use the following two facts:\n\n* We have seen mathematician and physicist in the same role in a sentence. Somehow they\n have a semantic relation.\n* We have seen mathematician in the same role in this new unseen sentence\n as we are now seeing physicist.\n\nand then infer that physicist is actually a good fit in the new unseen\nsentence? This is what we mean by a notion of similarity: we mean\n*semantic similarity*, not simply having similar orthographic\nrepresentations. It is a technique to combat the sparsity of linguistic\ndata, by connecting the dots between what we have seen and what we\nhaven't. This example of course relies on a fundamental linguistic\nassumption: that words appearing in similar contexts are related to each\nother semantically. This is called the `distributional\nhypothesis `__.\n\n\n### Getting Dense Word Embeddings\n\nHow can we solve this problem? That is, how could we actually encode\nsemantic similarity in words? Maybe we think up some semantic\nattributes. For example, we see that both mathematicians and physicists\ncan run, so maybe we give these words a high score for the \"is able to\nrun\" semantic attribute. Think of some other attributes, and imagine\nwhat you might score some common words on those attributes.\n\nIf each attribute is a dimension, then we might give each word a vector,\nlike this:\n\n\\begin{align}q_\\text{mathematician} = \\left[ \\overbrace{2.3}^\\text{can run},\n \\overbrace{9.4}^\\text{likes coffee}, \\overbrace{-5.5}^\\text{majored in Physics}, \\dots \\right]\\end{align}\n\n\\begin{align}q_\\text{physicist} = \\left[ \\overbrace{2.5}^\\text{can run},\n \\overbrace{9.1}^\\text{likes coffee}, \\overbrace{6.4}^\\text{majored in Physics}, \\dots \\right]\\end{align}\n\nThen we can get a measure of similarity between these words by doing:\n\n\\begin{align}\\text{Similarity}(\\text{physicist}, \\text{mathematician}) = q_\\text{physicist} \\cdot q_\\text{mathematician}\\end{align}\n\nAlthough it is more common to normalize by the lengths:\n\n\\begin{align}\\text{Similarity}(\\text{physicist}, \\text{mathematician}) = \\frac{q_\\text{physicist} \\cdot q_\\text{mathematician}}\n {\\| q_\\text{physicist} \\| \\| q_\\text{mathematician} \\|} = \\cos (\\phi)\\end{align}\n\nWhere $\\phi$ is the angle between the two vectors. That way,\nextremely similar words (words whose embeddings point in the same\ndirection) will have similarity 1. Extremely dissimilar words should\nhave similarity -1.\n\n\nYou can think of the sparse one-hot vectors from the beginning of this\nsection as a special case of these new vectors we have defined, where\neach word basically has similarity 0, and we gave each word some unique\nsemantic attribute. These new vectors are *dense*, which is to say their\nentries are (typically) non-zero.\n\nBut these new vectors are a big pain: you could think of thousands of\ndifferent semantic attributes that might be relevant to determining\nsimilarity, and how on earth would you set the values of the different\nattributes? Central to the idea of deep learning is that the neural\nnetwork learns representations of the features, rather than requiring\nthe programmer to design them herself. So why not just let the word\nembeddings be parameters in our model, and then be updated during\ntraining? This is exactly what we will do. We will have some *latent\nsemantic attributes* that the network can, in principle, learn. Note\nthat the word embeddings will probably not be interpretable. That is,\nalthough with our hand-crafted vectors above we can see that\nmathematicians and physicists are similar in that they both like coffee,\nif we allow a neural network to learn the embeddings and see that both\nmathematicians and physicists have a large value in the second\ndimension, it is not clear what that means. They are similar in some\nlatent semantic dimension, but this probably has no interpretation to\nus.\n\n\nIn summary, **word embeddings are a representation of the *semantics* of\na word, efficiently encoding semantic information that might be relevant\nto the task at hand**. You can embed other things too: part of speech\ntags, parse trees, anything! The idea of feature embeddings is central\nto the field.\n\n\n### Word Embeddings in Pytorch\n\nBefore we get to a worked example and an exercise, a few quick notes\nabout how to use embeddings in Pytorch and in deep learning programming\nin general. Similar to how we defined a unique index for each word when\nmaking one-hot vectors, we also need to define an index for each word\nwhen using embeddings. These will be keys into a lookup table. That is,\nembeddings are stored as a $|V| \\times D$ matrix, where $D$\nis the dimensionality of the embeddings, such that the word assigned\nindex $i$ has its embedding stored in the $i$'th row of the\nmatrix. In all of my code, the mapping from words to indices is a\ndictionary named word\\_to\\_ix.\n\nThe module that allows you to use embeddings is torch.nn.Embedding,\nwhich takes two arguments: the vocabulary size, and the dimensionality\nof the embeddings.\n\nTo index into this table, you must use torch.LongTensor (since the\nindices are integers, not floats).\n\n\n\n\n\n```python\n# Author: Robert Guthrie\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\ntorch.manual_seed(1)\n```\n\n\n\n\n \n\n\n\n\n```python\nword_to_ix = {\"hello\": 0, \"world\": 1}\nembeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings\nlookup_tensor = torch.tensor([word_to_ix[\"hello\"]], dtype=torch.long)\nhello_embed = embeds(lookup_tensor)\nprint(hello_embed)\n```\n\n tensor([[ 0.6614, 0.2669, 0.0617, 0.6213, -0.4519]],\n grad_fn=)\n\n\nAn Example: N-Gram Language Modeling\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nRecall that in an n-gram language model, given a sequence of words\n$w$, we want to compute\n\n\\begin{align}P(w_i | w_{i-1}, w_{i-2}, \\dots, w_{i-n+1} )\\end{align}\n\nWhere $w_i$ is the ith word of the sequence.\n\nIn this example, we will compute the loss function on some training\nexamples and update the parameters with backpropagation.\n\n\n\n\n\n```python\nCONTEXT_SIZE = 2\nEMBEDDING_DIM = 10\n\n# We will use Shakespeare Sonnet 2\ntest_sentence = \"\"\"When forty winters shall besiege thy brow,\nAnd dig deep trenches in thy beauty's field,\nThy youth's proud livery so gazed on now,\nWill be a totter'd weed of small worth held:\nThen being asked, where all thy beauty lies,\nWhere all the treasure of thy lusty days;\nTo say, within thine own deep sunken eyes,\nWere an all-eating shame, and thriftless praise.\nHow much more praise deserv'd thy beauty's use,\nIf thou couldst answer 'This fair child of mine\nShall sum my count, and make my old excuse,'\nProving his beauty by succession thine!\nThis were to be new made when thou art old,\nAnd see thy blood warm when thou feel'st it cold.\"\"\".split()\n# we should tokenize the input, but we will ignore that for now\n# build a list of tuples. Each tuple is ([ word_i-2, word_i-1 ], target word)\ntrigrams = [([test_sentence[i], test_sentence[i + 1]], test_sentence[i + 2])\n for i in range(len(test_sentence) - 2)]\n# print the first 3, just so you can see what they look like\nprint(trigrams[:3])\n\nvocab = set(test_sentence)\nword_to_ix = {word: i for i, word in enumerate(vocab)}\n\n\nclass NGramLanguageModeler(nn.Module):\n\n def __init__(self, vocab_size, embedding_dim, context_size):\n super(NGramLanguageModeler, self).__init__()\n self.embeddings = nn.Embedding(vocab_size, embedding_dim)\n self.linear1 = nn.Linear(context_size * embedding_dim, 128)\n self.linear2 = nn.Linear(128, vocab_size)\n\n def forward(self, inputs):\n embeds = self.embeddings(inputs).view((1, -1))\n out = F.relu(self.linear1(embeds))\n out = self.linear2(out)\n log_probs = F.log_softmax(out, dim=1)\n return log_probs\n\n\nlosses = []\nloss_function = nn.NLLLoss()\nmodel = NGramLanguageModeler(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE)\noptimizer = optim.SGD(model.parameters(), lr=0.001)\n\nfor epoch in range(10):\n total_loss = 0\n for context, target in trigrams:\n\n # Step 1. Prepare the inputs to be passed to the model (i.e, turn the words\n # into integer indices and wrap them in tensors)\n context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\n\n # Step 2. Recall that torch *accumulates* gradients. Before passing in a\n # new instance, you need to zero out the gradients from the old\n # instance\n model.zero_grad()\n\n # Step 3. Run the forward pass, getting log probabilities over next\n # words\n log_probs = model(context_idxs)\n\n # Step 4. Compute your loss function. (Again, Torch wants the target\n # word wrapped in a tensor)\n loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))\n\n # Step 5. Do the backward pass and update the gradient\n loss.backward()\n optimizer.step()\n\n # Get the Python number from a 1-element Tensor by calling tensor.item()\n total_loss += loss.item()\n losses.append(total_loss)\nprint(losses) # The loss decreased every iteration over the training data!\n```\n\n [(['When', 'forty'], 'winters'), (['forty', 'winters'], 'shall'), (['winters', 'shall'], 'besiege')]\n\n\n /home/david/anaconda3/envs/pytorch_tutorial/lib/python3.7/site-packages/torch/autograd/__init__.py:132: UserWarning: CUDA initialization: Found no NVIDIA driver on your system. Please check that you have an NVIDIA GPU and installed a driver from http://www.nvidia.com/Download/index.aspx (Triggered internally at /pytorch/c10/cuda/CUDAFunctions.cpp:100.)\n allow_unreachable=True) # allow_unreachable flag\n\n\n [523.2164900302887, 520.5518922805786, 517.9080045223236, 515.2833998203278, 512.6777231693268, 510.08880162239075, 507.51598358154297, 504.9569056034088, 502.41165256500244, 499.8801546096802]\n\n\n### Exercise: Computing Word Embeddings: Continuous Bag-of-Words\n\nThe Continuous Bag-of-Words model (CBOW) is frequently used in NLP deep\nlearning. It is a model that tries to predict words given the context of\na few words before and a few words after the target word. This is\ndistinct from language modeling, since CBOW is not sequential and does\nnot have to be probabilistic. Typcially, CBOW is used to quickly train\nword embeddings, and these embeddings are used to initialize the\nembeddings of some more complicated model. Usually, this is referred to\nas *pretraining embeddings*. It almost always helps performance a couple\nof percent.\n\nThe CBOW model is as follows. Given a target word $w_i$ and an\n$N$ context window on each side, $w_{i-1}, \\dots, w_{i-N}$\nand $w_{i+1}, \\dots, w_{i+N}$, referring to all context words\ncollectively as $C$, CBOW tries to minimize\n\n\\begin{align}-\\log p(w_i | C) = -\\log \\text{Softmax}(A(\\sum_{w \\in C} q_w) + b)\\end{align}\n\nwhere $q_w$ is the embedding for word $w$.\n\nImplement this model in Pytorch by filling in the class below. Some\ntips:\n\n* Think about which parameters you need to define.\n* Make sure you know what shape each operation expects. Use .view() if you need to\n reshape.\n\n\n\n\n\n```python\nCONTEXT_SIZE = 2 # 2 words to the left, 2 to the right\nraw_text = \"\"\"We are about to study the idea of a computational process.\nComputational processes are abstract beings that inhabit computers.\nAs they evolve, processes manipulate other abstract things called data.\nThe evolution of a process is directed by a pattern of rules\ncalled a program. People create programs to direct processes. In effect,\nwe conjure the spirits of the computer with our spells.\"\"\".split()\n\n# By deriving a set from `raw_text`, we deduplicate the array\nvocab = set(raw_text)\nvocab_size = len(vocab)\n\nword_to_ix = {word: i for i, word in enumerate(vocab)}\ndata = []\nfor i in range(2, len(raw_text) - 2):\n context = [raw_text[i - 2], raw_text[i - 1],\n raw_text[i + 1], raw_text[i + 2]]\n target = raw_text[i]\n data.append((context, target))\nprint(data[:5])\n\n\nclass CBOW(nn.Module):\n\n def __init__(self, embedding_dim, context_size, vocab_size, dropout=0.2):\n super().__init__()\n self.embedding = nn.Embedding(vocab_size, embedding_dim)\n self.dropout = nn.Dropout(dropout)\n self.linear = nn.Linear(embedding_dim, vocab_size)\n\n def forward(self, inputs):\n emb = self.embedding(inputs)\n mean = emb.mean(dim=1)\n out = self.linear(self.dropout(mean))\n log_probs = F.log_softmax(out, dim=1)\n return log_probs\n\n# create your model and train. here are some functions to help you make\n# the data ready for use by your module\n\n\ndef make_context_vector(context, word_to_ix):\n idxs = [word_to_ix[w] for w in context]\n return torch.tensor(idxs, dtype=torch.long)\n\ncbow = CBOW(embedding_dim=128,\n context_size=CONTEXT_SIZE,\n vocab_size=vocab_size,\n dropout=0.3\n )\n\n# make_context_vector(data[0][0], word_to_ix) # example\n\nlosses = []\nloss_function = nn.NLLLoss()\noptimizer = optim.SGD(cbow.parameters(), lr=0.01)\n\nfor epoch in range(40):\n total_loss = 0\n accuracy = 0\n \n for context, target in data:\n\n # Step 1. Prepare the inputs to be passed to the model (i.e, turn the words\n # into integer indices and wrap them in tensors)\n context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\n context_idxs.unsqueeze_(0)\n target_idx = word_to_ix[target]\n\n # Step 2. Recall that torch *accumulates* gradients. Before passing in a\n # new instance, you need to zero out the gradients from the old\n # instance\n cbow.zero_grad()\n\n # Step 3. Run the forward pass, getting log probabilities over next\n # words\n log_probs = cbow(context_idxs)\n\n # Step 4. Compute your loss function. (Again, Torch wants the target\n # word wrapped in a tensor)\n loss = loss_function(log_probs, torch.tensor([target_idx], dtype=torch.long))\n\n # Step 5. Do the backward pass and update the gradient\n loss.backward()\n optimizer.step()\n\n # Get the Python number from a 1-element Tensor by calling tensor.item()\n total_loss += loss.item()\n accuracy += int(log_probs[0, target_idx].item() == log_probs.max().item())\n print(epoch, total_loss, accuracy / len(data))\n# losses.append(total_loss)\n# print(losses) # The loss decreased every iteration over the training data!\n```\n\n [(['We', 'are', 'to', 'study'], 'about'), (['are', 'about', 'study', 'the'], 'to'), (['about', 'to', 'the', 'idea'], 'study'), (['to', 'study', 'idea', 'of'], 'the'), (['study', 'the', 'of', 'a'], 'idea')]\n 0 229.44551348686218 0.034482758620689655\n 1 212.36824202537537 0.15517241379310345\n 2 198.85704636573792 0.25862068965517243\n 3 180.80183136463165 0.41379310344827586\n 4 166.52524602413177 0.5344827586206896\n 5 152.50107324123383 0.6379310344827587\n 6 139.02809083461761 0.7413793103448276\n 7 127.54271537065506 0.7758620689655172\n 8 117.17048120498657 0.7586206896551724\n 9 105.72454649209976 0.8793103448275862\n 10 96.6032275557518 0.9137931034482759\n 11 93.59943437576294 0.896551724137931\n 12 83.87378299236298 0.9482758620689655\n 13 79.1644244492054 0.9137931034482759\n 14 70.42980808019638 0.9655172413793104\n 15 65.1251906901598 0.9310344827586207\n 16 61.93721008300781 0.9655172413793104\n 17 57.70122781395912 0.9655172413793104\n 18 52.533589869737625 0.9827586206896551\n 19 50.15311957895756 1.0\n 20 45.04634390771389 0.9827586206896551\n 21 41.83073575794697 1.0\n 22 41.64148707687855 1.0\n 23 36.46293383836746 1.0\n 24 38.303029738366604 1.0\n 25 34.484288811683655 1.0\n 26 32.70081126317382 0.9827586206896551\n 27 31.872529692947865 1.0\n 28 32.101080395281315 1.0\n 29 27.523721009492874 1.0\n 30 27.361480586230755 0.9827586206896551\n 31 25.17284446209669 1.0\n 32 23.987557873129845 1.0\n 33 23.426055818796158 1.0\n 34 23.307042837142944 0.9827586206896551\n 35 23.03582063317299 1.0\n 36 18.611751787364483 1.0\n 37 19.797190058976412 1.0\n 38 18.018043760210276 1.0\n 39 21.121414752677083 1.0\n\n\n\n```python\n\n```\n\n\n\n\n True\n\n\n\n\n```python\nimport pandas as pd\n\nwith torch.no_grad():\n context, target = data[0]\n probs = cbow.forward(make_context_vector(context, word_to_ix).unsqueeze(0)).exp()\n probs = pd.Series(probs[0,:], index=pd.Series(word_to_ix).sort_values().index)\n probs.sort_values(ascending=False, inplace=True)\n print(context, target)\n print(probs.head())\n```\n\n ['We', 'are', 'to', 'study'] about\n about 0.369349\n to 0.060599\n direct 0.046123\n study 0.044743\n abstract 0.035333\n dtype: float32\n\n\n\n```python\ncv = make_context_vector(data[0][0], word_to_ix)\ncv\n```\n\n\n\n\n tensor([47, 9, 17, 26])\n\n\n\n\n```python\nx = torch.stack((torch.tensor([0, 1, 2, 3], dtype=torch.long), torch.tensor([1, 2, 3, 4], dtype=torch.long)))\nx\n```\n\n\n\n\n tensor([[0, 1, 2, 3],\n [1, 2, 3, 4]])\n\n\n\n\n```python\ncbow.forward(x)\n```\n\n\n\n\n tensor([[-4.4479, -4.2165, -4.5860, -4.5395, -3.7475, -4.5314, -3.7213, -4.0955,\n -4.8205, -4.0684, -3.6109, -3.5902, -3.8569, -3.9649, -4.1915, -3.2609,\n -3.0084, -3.5542, -3.7935, -3.9100, -4.0027, -3.7444, -3.4058, -4.6186,\n -4.1976, -4.5493, -4.2081, -3.8594, -4.0403, -3.9142, -4.2514, -3.1725,\n -3.4688, -3.8114, -4.1353, -4.5739, -3.9951, -3.8958, -4.5362, -3.5117,\n -4.3187, -4.1432, -3.3839, -3.8355, -3.2985, -4.3572, -4.1291, -3.7987,\n -4.4616],\n [-4.4558, -4.0547, -4.5895, -4.1631, -3.5207, -4.3959, -3.6764, -4.1521,\n -4.5325, -3.9598, -3.7226, -3.6905, -3.6675, -3.5535, -4.5920, -3.3486,\n -2.9139, -3.3886, -3.7945, -3.9487, -4.0804, -3.6835, -3.5717, -4.4634,\n -4.1868, -4.5007, -4.1608, -4.0200, -3.9595, -4.2383, -4.4310, -3.4103,\n -3.4146, -3.5726, -4.1631, -4.5518, -3.9424, -4.0735, -4.5185, -3.6759,\n -3.9827, -4.4178, -3.5523, -4.0912, -3.3532, -4.3526, -4.5390, -3.5197,\n -4.5749]], grad_fn=)\n\n\n\n\n```python\ne = cbow.embedding(x)\n```\n\n\n```python\ne[0,], e[1,]\n```\n\n\n\n\n (tensor([[-0.4304, -0.6461, 1.0047],\n [ 0.1560, 1.4759, 1.0045],\n [-1.5860, -0.7552, 1.1779],\n [ 0.2058, 1.3878, 0.4951]], grad_fn=),\n tensor([[ 0.1560, 1.4759, 1.0045],\n [-1.5860, -0.7552, 1.1779],\n [ 0.2058, 1.3878, 0.4951],\n [ 1.4094, -0.0457, -0.9737]], grad_fn=))\n\n\n\n\n```python\ne.mean(dim=1)\n```\n\n\n\n\n tensor([[-0.4136, 0.3656, 0.9205],\n [ 0.0463, 0.5157, 0.4259]], grad_fn=)\n\n\n", "meta": {"hexsha": "0aa0f439e2194dcc2323ee21f4d1f6f41691f7e0", "size": 28934, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "beginner_source/nlp/3 word_embeddings_tutorial.ipynb", "max_stars_repo_name": "davidlove/pytorch_tutorials", "max_stars_repo_head_hexsha": "72cccf8754bf799ac1270a1ad9e05f8006b39e21", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "beginner_source/nlp/3 word_embeddings_tutorial.ipynb", "max_issues_repo_name": "davidlove/pytorch_tutorials", "max_issues_repo_head_hexsha": "72cccf8754bf799ac1270a1ad9e05f8006b39e21", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "beginner_source/nlp/3 word_embeddings_tutorial.ipynb", "max_forks_repo_name": "davidlove/pytorch_tutorials", "max_forks_repo_head_hexsha": "72cccf8754bf799ac1270a1ad9e05f8006b39e21", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.1715039578, "max_line_length": 366, "alphanum_fraction": 0.5799059929, "converted": true, "num_tokens": 6148, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657963619520866, "lm_q2_score": 0.30735800417608683, "lm_q1q2_score": 0.1464805658119249}}
{"text": "\n\n GEOS 657 Microwave Remote Sensing \n\n Lab 3: SAR Imaging Theory and Processing Methods -- [20 Points] \nAssignment Due Date: March 05, 2019 Paul A Rosen with modifications by Franz J Meyer \n Date: Feb 14, 2021 \n \n\n\n\n THIS NOTEBOOK INCLUDES A HOMEWORK ASSIGNMENT! \n The homework assignments in this lab are indicated by markdown fields with red background \n \n
\n\n\n```python\nimport url_widget as url_w\nnotebookUrl = url_w.URLWidget()\ndisplay(notebookUrl)\n```\n\n\n```python\nfrom IPython.display import Markdown\nfrom IPython.display import display\n\nnotebookUrl = notebookUrl.value\nuser = !echo $JUPYTERHUB_USER\nenv = !echo $CONDA_PREFIX\nif env[0] == '':\n env[0] = 'Python 3 (base)'\nif env[0] != '/home/jovyan/.local/envs/rtc_analysis':\n display(Markdown(f'WARNING: This notebook should be run using the \"rtc_analysis\" conda environment. '))\n display(Markdown(f'It is currently using the \"{env[0].split(\"/\")[-1]}\" environment. '))\n display(Markdown(f'Select the \"rtc_analysis\" from the \"Change Kernel\" submenu of the \"Kernel\" menu. '))\n display(Markdown(f'If the \"rtc_analysis\" environment is not present, use Create_OSL_Conda_Environments.ipynb to create it. '))\n display(Markdown(f'Note that you must restart your server after creating a new environment before it is usable by notebooks. '))\n```\n\n# Prepare the Notebook\n\n\n```python\nimport warnings\nwarnings.filterwarnings('ignore')\n\nbShowInline = True # Set = False for document generation\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nparams = {'legend.fontsize': 'x-large',\n 'figure.figsize': (15, 5),\n 'axes.labelsize': 'x-large',\n 'axes.titlesize':'x-large',\n 'xtick.labelsize':'x-large',\n 'ytick.labelsize':'x-large'}\nplt.rcParams.update(params)\n\ndef makeplot( plt, figlabel, figcaption):\n figname = figlabel+'.png'\n\n plt.savefig(figname)\n\n if bShowInline:\n plt.show()\n else:\n plt.close()\n\n strLatex=\"\"\"\n \\\\begin{figure}[b]\n \\centering\n \\includegraphics[totalheight=10.0cm]{%s}\n \\caption{%s}\n \\label{fig:%s}\n \\end{figure}\"\"\"%(figname, figcaption, figlabel) \n return display(Latex(strLatex)) \n\ndef sinc_interp(x, s, u):\n # x is the vector to be interpolated\n # s is a vector of sample points of x\n # u is a vector of the output sample points for the interpolation\n \n if len(x) != len(s):\n raise ValueError('x and s must be the same length')\n \n # Find the period \n T = s[1] - s[0]\n \n sincM = np.tile(u, (len(s), 1)) - np.tile(s[:, np.newaxis], (1, len(u)))\n y = np.dot(x, np.sinc(sincM/T))\n return y\n\n%matplotlib widget\nplt.rcParams.update({'font.size': 11})\n```\n\n# Overview\n\n In this notebook, we will demonstrate the generation of a raw synthetic aperture radar data set for a collection of point scatterers on an otherwise dark background, and then demonstrate two methods of processing the data, simple back projection, and range-doppler processing.\n\n1.0 [Background](#section-1) \n\n# 1.0 Background \n\n## 1.1 SAR Geometry \n\nTo simplify the problem, we assume a spacecraft flying at fixed altitude $h_{sc}$ and constant velocity $v_{sc}$, observing points on a flat earth. The geometry of the observation is depicted in Figure 1. The radar antenna is assumed to be a flat rectangular aperture with dimensions of length $L_a$ in the along-track dimension (also known as \"azimuth\" for historical reasons), and width \"W_a\" in the cross-track dimension (also known as the elevation dimension). The range $\\rho$ is the distance from the spacecraft antenna to a point on the ground. The \"range vector\" or \"look vector\" is the vector pointing in this direction, with magnitude $\\rho$. At this range, the look angle, defined as the angle from nadir to the range vector is $\\theta$. At the antenna boresight, which is the direction where the antenna pattern has its peak gain, we define the boresight reference range $\\rho_l$, and corresponding look angle $\\theta_l$. Figure 2 illustrates the case where the antenna is pointed forward toward the velocity vector. In this configuration, we define squint angle $\\theta_{sq}$ as the angle of rotation about the nadir vector in the ground plane.\n\nTable 1 lists the assumed spacecraft, radar, and surface point targets characteristics. \n\n\n \n \n SAR Geometry \n \n \n \n \n \n \n Figure 1. Basic SAR Geometry \n Figure 2. Squinted SAR Geometry \n \n \n
\n\n\n**Table 1. Radar and Spacecraft Parameters**\n\n| Parameter | Symbol | Value | Comment |\n| --- | --- | --- | --- | \n| Wavelength | $\\lambda $ | 0.24 m | (L-band) \n| Antenna Length | $L_a$ | 10 m | | \n| Antenna Width | $W_a$ | 2 m | | \n| Off-nadir boresight angle | $\\theta_l$ | 30$^\\circ$ | |\n| Azimuth squint of boresight angle | $\\theta_{sq}$ | 0$^\\circ$ | |\n| Spacecraft Velocity | $v_{sc}$ | 7,500 m/s | Assumed constant |\n| Spacecraft Altitude | $h_{sc}$ | 750,000 m | Assumed constant | \n| Radar Range Bandwidth | $B_r$ | 10 MHz | |\n| Radar Pulse Duration | $\\tau_r$ | 20 $\\mu$s | Determines average power |\n| Nominal Pulse Rate | $f_p$ | 1600 Hz | Determines average power and ambiguity levels |\n| Peak Power on Transmit | $P_T$ | 4,000 W | Determines SNR |\n| Radar Noise Temperature | $T_r$ | 300 K | Determines SNR |\n| Corner Reflector Dimension | $L_{cr}$ | 2.4 m | Determines SNR |\n\n\n```python\nimport numpy as np\nLambda = 0.24\nL_a = 10.\nW_a = 2. \ntheta_l = 30. * np.pi/180.\ntheta_sq = 0. * np.pi/180.\nv_sc = 7500.\nh_sc = 750000. \nB_r = 20.e6\ntau_r = 10.e-6\nf_p = 1600.\nP_T = 4000.\nT_r = 300.\nL_cr =2.4\n```\n\n**Table 2. Other Constants**\n\n| Parameter | Symbol | Value | Comment |\n| --- | --- | --- | --- | \n| Speed of light | $c $ | 299792456 m/s | | \n| Boltzman constant | $k$ | 1.38064852 $\\times$ 10$^{-23}$ m$^2$ kg s$^{-2}$ K$^{-1}$ | -228.6 dB | \n| Gravitational Constant | $G$ | 6.672 $\\times$ 10$^{-11}$ m$^3$ kg$^{−1}$ s$^{−2}$ | | \n| Earth's Mass | $M_E$ | 5.9742 $\\times$ 10$^{24}$ kg | |\n\n\n```python\nc = 299792456 \nk = 1.38064852e-23\nG = 6.672e-11\nM_E = 5.9742e24\n```\n\n\n
ASSIGNMENT #1 : Calculate Expected Range Resolution \n\n
Based on the variables shown in Tables 1 and 2 you can calculate the expected range resolution $\\rho_r$ of this simulated SAR data set. \n\nPlease answer the following questions :\n\n\nQuestion 1.1 : List the variables (with their values) from Tables 1 and 2 that are needed to calculate the range resolution$\\rho_r$ .Question 1.2 : Provide the equation for calculating $\\rho_r$ and provide your calculated value in the units of [meters]. \n \n
The radar antenna directs the radar signal toward a particular area on the ground. Generally, the larger the antenna, the more directed the energy is toward a particular direction. Most SAR radar antennas are rectangular planar antennas, though there are exceptions. A simple model for a planar antenna's power radiation pattern is a sin x / x function:\n\n\\begin{equation}\nS(\\theta_{az}, \\theta_{el}; \\theta_l, \\theta_{sq}) = \n\\bigg [\\frac{\n\\sin \\pi\\big (\\frac{\\theta_{az}-\\theta_{sq}}{\\theta_{L_a}}\\big )\n}\n{\n\\pi \\big (\\frac{\\theta_{az}-\\theta_{sq}}{\\theta_{L_a}}\\big )\n} \\bigg ]^2\n\\bigg [\\frac{\n\\sin \\pi\\big (\\frac{\\theta_{el}-\\theta_{l}}{\\theta_{W_a}}\\big )\n}\n{\n\\pi\\big (\\frac{\\theta_{el}-\\theta_{l}}{\\theta_{W_a}}\\big )\n} \\bigg ]^2\n\\end{equation}\n\nThe \"half-power beamwidth\" of the antenna with respect to its Length (along velocity vector) and with respect to its Width (direction perpendicular to the velocity vector and to the off-nadir boresight)\n\n\\begin{equation}\n\\theta_{L_a} = 0.87 \\frac{\\lambda}{L_a}\n\\end{equation}\n\n\\begin{equation}\n\\theta_{W_a} = 0.87 \\frac{\\lambda}{W_a}\n\\end{equation}\n\nAt these angles, the power of the signal at this angular extent has been reduced half, or 3 dB. This is also called the 3dB beamwidth.\n\nA SAR antenna points to one side of the flight track or another, usually with an angle greater than 20$^\\circ$. This is to ensure a unique relationship between the time of return and the distance from the spacecraft to the ground. If the energy from the radar illuminates both sides of the radar track, there will be a left-right ambiguity in range for a given time. In practice the antenna sidelobes in the sin x / x pattern will lead to some energy everywhere, but the farther off-nadir the antenna is pointed, the lower this energy is from unwanted directions. Angles larger than 20$^\\circ$ also help avoid excessive foreshortening of the observations. \n\n\n```python\ntheta_L_a = 0.866 * Lambda/L_a \ntheta_W_a = 0.866 * Lambda/W_a\n```\n\nWe can see the values in degrees in these two dimensions:\n\n\n```python\nprint(\" Along track half-power beamwidth =\",\"{:.2f}\".format(theta_L_a * 180. / np.pi),\"degrees\")\nprint(\" Elevation half-power beamwidth =\",\"{:.2f}\".format(theta_W_a * 180. / np.pi),\"degrees\")\n```\n\n\n```python\ntheta_az=np.linspace(-np.pi/32., np.pi/32., 400)\ntheta_el=np.linspace(-np.pi/8., np.pi/8., 400)+theta_l\nSaz = (np.sinc((theta_az-theta_sq)/theta_L_a))**2 \nSel = (np.sinc((theta_el-theta_l )/theta_W_a))**2\n```\n\n\n```python\ndef S_p (th_az, th_el):\n return (np.sinc((th_az-theta_sq)/theta_L_a))**2 * (np.sinc((th_el-theta_l)/theta_W_a))**2\n\nTheta_az, Theta_el = np.meshgrid(theta_az,theta_el)\nS = S_p(Theta_az, Theta_el)\n```\n\n\n```python\nplt.style.use('seaborn-whitegrid')\n\nplt.figure(figsize=(13, 5))\nplt.subplot(1,2,1)\nplt.plot(180.*theta_az/np.pi,Saz,label='az')\nplt.plot(180.*theta_el/np.pi,Sel,label='el')\nplt.legend(loc='best')\nplt.title(\"Idealized 1-d El/Az \\n Radiation Patterns of a Planar Antenna\")\nplt.xlabel(\"Beam Angles $(^\\circ)$\")\nplt.ylabel(\"Power\")\n\nplt.subplot(1,2,2)\nplt.contourf(180.*Theta_az/np.pi, 180.*Theta_el/np.pi, 10.*np.log10(S), 20, cmap='magma')\nplt.colorbar(label='Power (dB)')\nplt.title(\"Idealized 2-d \\nRadiation Pattern of a Planar Antenna\")\nplt.xlabel(\"Along track Beam Angle $ (^\\circ)$\")\nplt.ylabel(\"Elevation Beam Angle $ (^\\circ)$\")\n#plt.subplots_adjust(left=-0.1,top=0.9)\n```\n\n## 1.3 Beam Extent and Swath\n\nFrom the elevation beamwidth and other geometric parameters described above, we can calculate the range $\\rho$ and ground range $\\rho_g$ where the boresight and the 3-dB beam edges intersect the flat Earth. Specifically, we define:\n\n| Parameter | Symbol | \n| --- | --- | \n| Generic Range | $\\rho $ |\n| Generic Ground Range | $\\rho_g$ |\n| Range at Boresight | $\\rho_l$ |\n| Ground Range at Boresight | $\\rho_{l,g}$ | \n| Range at Near Beam Edge | $\\rho_n$ |\n| Ground Range at Near Beam Edge | $\\rho_{n,g}$ | \n| Range at Far Beam Edge | $\\rho_f$ |\n| Ground Range at Far Beam Edge | $\\rho_{f,g}$ | \n| Reference azimuth for calculations | $s_0$ | \n| Reference range for calculations | $\\rho_0$ | \n \n\n\n```python\nrho_l = h_sc / np.cos(theta_l)\nrho_lg = h_sc * np.sin(theta_l)\nrho_n = h_sc / np.cos(theta_l-theta_W_a/2)\nrho_ng = h_sc * np.sin(theta_l-theta_W_a/2)\nrho_f = h_sc / np.cos(theta_l+theta_W_a/2)\nrho_fg = h_sc * np.sin(theta_l+theta_W_a/2)\nrho_sw = rho_fg-rho_ng\nDelta_rho = c / (2. * B_r)\nDelta_rho_ng = Delta_rho / np.sin(theta_l-theta_W_a/2)\nDelta_rho_fg = Delta_rho / np.sin(theta_l+theta_W_a/2)\nn_rs=int(np.round(rho_sw/Delta_rho))\nrho_v=np.linspace(rho_n,rho_f,n_rs)\ns_0 = 0. # reference azimuth for defining calculations\nrho_0 = rho_l \n```\n\nFrom these ranges, we can calculate the swath extent in meters on the ground $\\rho_{fg}-\\rho_{ng}$. \n\n\n```python\nprint(\"Boresight range: \",\"{:.2f}\".format(rho_l),\"m\")\nprint(\"Range swath: \",\"{:.2f}\".format(rho_sw),\"m\")\n```\n\nThe along track beam extent on the ground in meters is given by $\\rho \\theta_{L_a}$, where $\\rho$ varies across the swath. In the near range, the azimuth beam extent is \n\n\n```python\nprint(\"Near range azimuth beam extent: \",\"{:.2f}\".format(rho_n * theta_L_a),\"m\")\n```\n\nwhile in the far range, the azimuth beam extent is \n\n\n```python\nprint(\"Far range azimuth beam extent: \",\"{:.2f}\".format(rho_f * theta_L_a),\"m\")\n```\n\nWe will use the far range azimuth beamwidth to define the simulation extent in azimuth. Let's specify an extent that is 3 beamwidths to get a number of full synthetic apertures. \n\n| Parameter | Symbol | \n| --- | --- | \n| Along Track Position Half Beamwidth In Advance of $s_0$ | $s_{s,{\\rm hb}} $ |\n| Along Track Position Half Beamwidth After $s_0$ | $s_{e,{\\rm hb}} $ |\n| Along Track Position At Simulation Start | $s_{s,{\\rm sim}}$ |\n| Along Track Position at Simulation End | $s_{e,{\\rm sim}}$ | \n\nwhere\n\\begin{equation}\n\\begin{array}{lr}\ns_{s,{\\rm hb}} & = & s_0 - \\rho_f \\theta_{L_a} / 2 \\\\\ns_{e,{\\rm hb}} & = & s_0 + \\rho_f \\theta_{L_a} / 2 \\\\\ns_{s,{\\rm sim}} & = & s_0 - 3 \\rho_f \\theta_{L_a} / 2 \\\\\ns_{e,{\\rm sim}} & = & s_0 + 3 \\rho_f \\theta_{L_a} / 2 \\\\\n\\end{array}\n\\end{equation}\n \n\n\n```python\ns_s_hb = s_0 - rho_f * theta_L_a / 2. # half beamwidth\ns_e_hb = s_0 + rho_f * theta_L_a / 2. # half beamwidth\ns_s_sim = s_0 - 3. * rho_f * theta_L_a / 2. # total of 3 beamwidths for simulation\ns_e_sim = s_0 + 3. * rho_f * theta_L_a / 2. # total of 3 beamwidths for simulation\n```\n\n## 1.4 Phase and Doppler Frequency \n\n\nLet's pick a bright point on the ground, say at $(\\rho_0, s_0)$, or equivalently $(\\rho_{0g}, s_0)$. As the spacecraft flies along track and observes the point, the distance from the spacecraft to the point is changing hyperbolically: \n\n\n\\begin{equation}\n\\rho(s;\\rho_0,s_0) = \\sqrt{(s-s_0)^2+\\rho_0^2}\n\\end{equation}\n \n\nThe phase of the wave that travels from the spacecraft to the ground point and back is $-\\frac{4 \\pi}{\\lambda} \\rho(s)$. Over the extent of time that this point is illuminated, the range at which the point will appear in the echo, and the phase of the point, will vary as plotted below. To make the plot we need to understand how to properly sample the function we are plotting. Since the functions are hyperbolic, the range and phase increase quasi-quadratically. The derivative of the phase is the frequency, and this then varies quasi-linearly. This implies that there is bandwidth associated with the received signal in azimuth, related to the fact that the radar is moving relative to the point on the ground, so there is a Doppler shift of the signal that varies as the azimuth aspect angle changes. We will see later that the Doppler bandwidth is given approximately by the velocity and the azimuth antenna length: $B_d = 2 v_{sc} / L_a$. \n\n\n```python\nB_d = 2. * v_sc / L_a\n```\n\n\n```python\nprint(\"Doppler Bandwidth: \",\"{:.2f}\".format(B_d),\"Hz\") # in Hz or cycles/second\n```\n\nTherefore if we want to sample a signal properly, we need to sample at this frequency for complex signals, or twice for real signals according to the Nyquist criterion. \n\nThe azimuth aperture time for any target is related to the azimuth extent on the ground: $t_a = \\rho * \\theta_{L_a} / v_{sc}$. \n\n\n```python\nt_af = rho_f * theta_L_a / v_sc\n```\n\n\n```python\nprint(\"Synthetic Aperture time in far range: \",\"{:.2f}\".format(t_af),\"sec\")\n```\n\nThe time-bandwidth product gives the number of points needed to adequately represent the signal over this frequency range. \n\n\n```python\nn_af = int(np.round(B_d * t_af))\n```\n\nTo examine the function, we need to pick a point for the point target. Let's assume $s_0=0$ and $\\rho_0 = \\rho_l$. We also remove the large offset phase $-4 \\pi \\rho_0 / \\lambda$, since the absolute phase is difficult to measure and arbitrary.\n\n\\begin{equation}\n\\phi_{az}(s;\\rho_0,s_0) = -\\frac{4\\pi}{\\lambda} (\\rho(s;\\rho_0,s_0) - \\rho_0) = -\\frac{4\\pi}{\\lambda} (\\sqrt{(s-s_0)^2+\\rho_0^2} - \\rho_0)\n\\end{equation}\n\nAssuming $(s-s_0) << \\rho_0$, we can expand the square root by Taylor expansion to obtain\n\n\\begin{equation}\n\\phi_{az}(s;\\rho_0,s_0) \\approx -\\frac{4\\pi}{\\lambda} \\frac{1}{2}\\frac{(s-s_0)^2}{\\rho_0}\n\\end{equation}\n\nwhich illustrates the quadratic nature of the phase to first order. \n\nThe spatial frequency in radians is then its derivative with $s$\n\n\\begin{equation}\n\\omega_{az}(s;\\rho_0,s_0) = -\\frac{4\\pi}{\\lambda} \\frac{(s-s_0)}{\\rho_0}\n\\end{equation}\n\nor in cycles\n\n\\begin{equation}\nf_{az}(s;\\rho_0,s_0) = -\\frac{2}{\\lambda} \\frac{(s-s_0)}{\\rho_0}\n\\end{equation}\n\nor in Hertz\n\n\\begin{equation}\nf_{az,hz}(s;\\rho_0,s_0) = -\\frac{2 v_{sc}}{\\lambda} \\frac{(s-s_0)}{\\rho_0}\n\\end{equation}\n \n\n\n\n\n```python\ns = np.linspace(s_s_hb, s_e_hb, n_af)\nphi_az = - ( 4. * np.pi * (np.sqrt(np.square(s-s_0)+rho_0*rho_0) / Lambda) - 4. * np.pi * rho_0 / Lambda)\nphi_az_approx = -4. * np.pi * np.square(s-s_0) /(2*Lambda*rho_0)\nf_az_hz = - (2. * v_sc / Lambda) * (s-s_0) / rho_0\n```\n\nIn the plot on the left below, the exact and quadratic expressions (Eqs. 6 and 7) are plotted. At this scale, the exact and approximate curves are indistinquishable. The plot on the right plots the difference on a scale where the impact of the approximation can be seen. It is a small fraction of the wavelength over the synthetic aperture. \n\n\n```python\nfig = plt.figure(figsize=(13, 6))\n\nax = fig.add_subplot(1,2,1)\nax.plot(s, phi_az, 'b', label=\"exact\")\nax.plot(s, phi_az_approx, 'r', label=\"quadratic approximation\")\nax.legend(loc='best')\nax.set_title(\"Along Track Phase History of an Illuminated Target\")\nax.set_xlabel(\"Along track position, s (m)\")\nax.set_ylabel(\"Phase (rad)\")\n\nax = fig.add_subplot(1,2,2)\nax.plot(s, (phi_az-phi_az_approx)/(2.*np.pi))\nax.set_title(\"Along Track Phase History Error of an Illuminated Target\")\nax.set_xlabel(\"Along track position, s (m)\")\nax.set_ylabel(\"Phase Error (wavelengths)\")\nplt.tight_layout()\n```\n\nThe Doppler bandwidth would be the range of the frequency function over this azimuth extent. \n\n\n```python\nfig = plt.figure(figsize=(13, 6))\n\nplt.title(\"Doppler History of an Illuminated Target\")\nplt.xlabel(\"Along track position, s (m)\")\nplt.ylabel(\"Doppler Frequency (Hz)\")\n\nplt.plot(s, f_az_hz)\nf_az_hz_bw = np.abs(f_az_hz[-1] - f_az_hz[0])\ndb_str = str(int(np.round(f_az_hz_bw)))\nplt.text(-7500.,-500.,\"Doppler Bandwidth = \"+db_str,fontsize=16);\n```\n\n## 1.5 Azimuth Resolution of the Synthetic Aperture\n\nGiven this bandwidth, what does this imply for resolution in azimuth? The time resolution is simply the reciprocal bandwidth: $ 1/f_{az,hz,bw}$, where $f_{az,hz,bw} = f_{az,hz}(s_{e,\\rm hb}) - f_{az,hz}(s_{s,\\rm hb})$. The spatial resolution would then be the velocity times this quantity: $ v_{sc}/f_{az,hz,bw}$. \n\n\n```python\nprint('Azimuth Resolution based on Doppler Bandwidth = ',np.round(100.*v_sc/f_az_hz_bw)/100.,' m')\n```\n\nThe theoretical resolution is typically quoted as $L_a/2$, half the antenna length in azimuth, independent of range and frequency. This can be seen by evaluating $f_{az,hz,bw}$ as follows:\n\n\\begin{eqnarray}\nf_{az,bw} &=& | f_{az}(s_{e,\\rm hb}) - f_{azz}(s_{s,\\rm hb}) |\\\\\n &=& \\frac{2}{\\lambda} \\frac{(s_{e,\\rm hb}-s_{s,\\rm hb})}{\\rho_0}\\\\\n &=& \\frac{2}{\\lambda} \\theta_{L_a} = -\\frac{2}{\\lambda} * 0.88 \\frac{\\lambda}{L_a} \n &=& 0.88 \\frac{2}{L_a}\n\\end{eqnarray}\n \n\n\n```python\nprint('Azimuth Resolution from calculation = ',np.round(100.*L_a/1.76)/100.,' m')\n```\n\nThe \"L/2\" azimuth resolution rule is an approximation, that will depend on the exact shape of the antenna pattern. But it is a good first approximation. \n\n## 1.6 The Radar Equation \n\nBefore we proceed with simulating an image with point targets, let's take a small diversion to develop an intuition about imaging performance for a radar with particular characteristics. This is typically accomplished through the radar equation, which calculates the signal-to-noise ratio of a system for a given scatterer on the ground. In this exercise, we'll consider a corner reflector as a scatterer.\n\nThe Radar Equation can be expressed as follows:\n\n\\begin{equation}\nP_R = P_T \\cdot G_T \\cdot \\frac{1}{4 \\pi \\rho^2} \\cdot \\sigma \\cdot \\frac{1}{4 \\pi \\rho^2} \\cdot A_a \\cdot \\epsilon\n\\end{equation}\n\nwhere the terms are defined as follows:\n\n| Parameter | Symbol | \n| --- | --- :| \n| Received Power | $P_R$ |\n| Transmitted Power | $P_T$ |\n| Antenna Transmit Gain | $G_T$ |\n| Range of Target | $\\rho$ |\n| Radar Cross Section of Target | $\\sigma$ |\n| Receive Antenna Area |$ A_a$ |\n| System Losses Fudge Factor | $\\epsilon$ |\n\nThis equation from left to right follows the transmitted signal through its echo path. The Antenna radiates a total power of $P_T$ from the aperture. That power is directed into the antenna beam by virtue of its size, and therefore has directivity: a concentration, or gain $G_T$ in a particular direction. This power then propagates a distance $\\rho$, spreading out over a spherically shaped surface within the beam. At the target, the power density then is \n\n$P_T \\cdot G_T \\cdot \\frac{1}{4 \\pi \\rho^2}$.\n\nThe target presents a reflecting surface which is characterized by its radar cross section. The radar cross section is the effective area that would lead to the observed total power reflected from a target hit with an incident power density. Thus, the reflected power at the target is\n\n$P_T \\cdot G_T \\cdot \\frac{1}{4 \\pi \\rho^2} \\cdot \\sigma$. \n\nThis power then propagates back to the radar as a spherical wave, such that the power density at the radar is \n\n$P_T \\cdot G_T \\cdot \\frac{1}{4 \\pi \\rho^2} \\cdot \\sigma \\cdot \\frac{1}{4 \\pi \\rho^2}. $\n\nThis power density hits the receive aperture, which collects the power over its area $A_a$. The system losses fudge factor accounts for losses of power in the receive chain before the signal is detected and may include transmit chain losses as well, depending on the definition of $P_T$ (is it the radiated power, or the power generated by the amplifiers which then needs to work its way through the antenna system to be radiated?). Typical system losses include: circulator losses, radiation inefficiency of the antenna, and antenna feed losses. These losses can be many factors of 2 loss in overall power generated by the radar power system. (There also are inefficiencies in getting the power from the spacecraft power system to the radar, but those are not included here.) \n\nTo calculate the received power, we need to define a target. In this tutorial, we are looking at corner reflectors. A corner reflector has a radar cross section \n\n\\begin{equation}\n\\sigma_{cr} = \\frac{4 \\pi L_{cr}^4}{3\\lambda^2}.\n\\end{equation}\n\nWe also need an expression for the gain of the antenna and the receive aperture size, which will be dependent on the look direction. The gain in the boresight direction $G_{Tl}$ is characterized by the beamwidths of the antenna:\n\n\\begin{equation}\nG_{Tl} = \\frac{4 \\pi}{\\theta_{L_a}\\theta_{W_a}}.\n\\end{equation}\n\nOff boresight, this gain will be reduced by the shape of the beam pattern on both transmit and on receive $S(\\theta_{az}, \\theta_{el}; \\theta_l, \\theta_{sq})^2$ (as opposed to just $S$).\n\n\\begin{equation}\nG_T(\\theta_{az}, \\theta_{el}; \\theta_l, \\theta_{sq}) = G_{Tl} S^2(\\theta_{az}, \\theta_{el}; \\theta_l, \\theta_{sq}).\n\\end{equation}\n \n\n\n```python\nG_Tl = 4 * np.pi /(theta_L_a * theta_W_a)\n```\n\n\n```python\nprint (\"Transmit antenna gain = \",\"{:.2f}\".format(10.*np.log10(G_Tl)),\"dB\") # since all quantities are powers already, this is the power gain in dB.\n```\n\nFor a corner reflector target located on ground at the boresight angle, we can calculate the receive power: \n\n\n```python\nsigma_cr = 4. * np.pi *L_cr**4/(3.*Lambda**2) \nA_a = L_a * W_a \nepsilon = 10.**(-5./10.) # assume 5 dB overall losses\nP_R = P_T * G_Tl * (1./(4.*np.pi*rho_l**2)) * sigma_cr * (1./(4.*np.pi*rho_l**2)) * A_a * epsilon\n```\n\n\n```python\nprint (\"Received power of corner reflector = \",\"{:.2f}\".format(10.*np.log10(P_R)),\"dB\") # in dB\n```\n\nIn order for the instrument to detect such a small amount of power, the noise level of the system must be commensurately small. The noise of an electronic system is given by \n\n\\begin{equation}\nP_N = k T_r B_r\n\\end{equation}\n\nwhere $k$ is the Boltzman constant, $T_r$ is the noise temperature of the radar, and $B_r$ is the bandwidth of the radar (Skolnik, Merrill I., Radar Handbook (2nd Edition). McGraw-Hill, 1990. ISBN 978-0-07-057913-2). The noise temperature is not necessarily the physical temperature. It is a combination of noise introduced by electron motion in electronics above absolute zero temperature and other noise sources. A reasonable noise temperature would be around 300 K. \n\n\n```python\nP_N = k* T_r * B_r\n```\n\n\n```python\nprint (\"Noise power = \",\"{:.2f}\".format(10.*np.log10(P_N)),\"dB\")\n```\n\n\n```python\nSNR = P_R/P_N\n```\n\n\n```python\nprint(\"SNR of corner reflector in raw data = \",\"{:.2f}\".format(10.*np.log10(SNR)),\"dB\")\n```\n\nIt looks like the SNR of a bright point target is well below the noise floor in this radar, and that is in general true in the raw data. The signals from individual scatterers or resolution cells in the raw data are quite dim. It is not until we focus the image that we concentrate the energy into a single point and build adequate SNR. \n\n# 2.0 Simulating SAR data with point targets \n\n## 2.1 Simulating the transmitted pulse\n\nOur radar will transmit pulses of energy at a pulse rate $f_r$ sufficient to sample the Doppler spectrum, the bandwidth of which was computed above. For our purposes, the pulse rate is set slightly higher than the Doppler bandwidth, which lowers aliasing of the energy outside this area of the spectrum. For any given pulse, we transmit a pulse of duration $\\tau_r$, sweeping the frequency linearly, to generate a signal with the required bandwidth $B_r$. The time-bandwidth product determine the number of samples required in this complex signal. Note: in reality we transmit and receive real-valued waveforms as currents excited or detected on the antenna. However, radar systems are coherent by nature, and the received signals are typically converted in hardware or on the ground to complex-valued waveforms. For this tutorial, we imagine that the transmit waveform is complex for simplicity. The frequency-swept, or \"chirp,\" waveform can be expressed as\n\n$C_r(t) = e^{i \\phi_r(t)} {\\rm rect}\\big(\\frac{t}{\\tau_r}\\big)$ where $\\phi_r(t) = \\pi \\frac{B_r}{\\tau_r} t^2 = \\pi \\frac{B_r}{\\tau_r} (2\\rho/c)^2 = 4 \\pi \\frac{B_r}{c^2\\tau_r} \\rho^2$, and the rect function is 1 on the interval 0 to 1, and 0 elsewhere. First, let's define these functions: \n\n\n```python\ndef rect(x):\n return np.abs(x) <= 0.5 \ndef win(x):\n return 1. # rectangular window\n# return 0.54 - 0.46 * np.cos(2.*np.pi*(x+0.5)) # hamming window defined on [-0.5,0.5] applied to suppress sidelobes.\n\ndef C_r_r(r):\n phi_r_r = 4. * np.pi * B_r / (c**2 * tau_r) * r**2\n return (np.cos(phi_r_r) + 1j * np.sin(phi_r_r)) * rect((r- c*tau_r/4.)/(c * tau_r/2.)) * win((r- c*tau_r/4.)/(c * tau_r/2.))\n```\n\nNow let's evaluate the chirp over the pulse length and examine some of its properties. The required number of samples is again the time-bandwidth product of the chirp. \n\n\n```python\nn_r = int(np.round(B_r * tau_r)) \nt_c = np.linspace(0.,tau_r,2*n_r) # create the arrays with twice the required points so real functions don't alias\nrho_c = c * t_c / 2.\nC_r = C_r_r(rho_c)\nphi_r = 4. * np.pi * B_r / (c**2 * tau_r) * rho_c**2\n```\n\n\n```python\nfig = plt.figure(figsize=(13, 5))\n\nax = fig.add_subplot(1,3,1)\nax.plot(rho_c,phi_r)\nax.set_title(\"Phase of the \\n Complex Chirp Signal\")\nax.set_xlabel(\"Range Distance along pulse (m)\")\nax.set_ylabel(\"Phase (Radians)\")\n\nax = fig.add_subplot(1,3,2)\nax.plot(rho_c,C_r.real)\nax.set_title(\"Real Part of the \\n Complex Chirp Signal\")\nax.set_xlabel(\"Range Distance along pulse (m)\")\nax.set_ylabel(\"Signal Magnitude\")\n\nax = fig.add_subplot(1,3,3)\nFC_r = np.fft.fft(C_r)\nfreq = np.fft.fftfreq(FC_r.shape[-1])\nnplts = int(np.round(FC_r.shape[-1]/2)) # only need the positive frequencies since it is a complex signal.\nax.plot(freq[0:nplts]*2.*B_r/1.e6, np.absolute(FC_r[0:nplts]))\nax.set_title(\"Spectrum of \\n Complex Chirp Signal\")\nax.set_xlabel(\"Frequency (MHz)\")\nax.set_ylabel(\"Magnitude\")\nplt.tight_layout()\n\nplt.show();\n```\n\nFeel free to play with the plotting limits of the array to explore the shape of the curve. Note that the complex chirp as created with twice the number of needed samples so that plotting the real or imaginary part, which is sinusoidal with increasing frequency, looks properly sampled in the plot. In reality, it is well sampled in the complex domain with half the point density. \n\n## 2.2 Simulating the Received Echoes\n\n\nNow we have a chirp signal, and when it encounters our corner reflector target, it will reflect some energy back to the radar. The echo signature of a corner reflector will be a delayed version of itself, with amplitude adjusted based on the shape of the antenna pattern and the losses as calculated in the radar equation above, and a phase shift proportional to the round-trip distance $2 \\rho$. Specifically, for a corner refector at $s_{cr},\\rho_{cr}$, the received echo will be:\n\n\\begin{equation}\nE_{cr}(s,\\rho; s_{cr},\\rho_{cr}) = \\sqrt{G_T\\big(\\theta_{az,cr}(s;s_{cr},\\rho_{cr}), \\theta_{el,cr}(\\rho_{cr}); \\theta_{l}, \\theta_{sq}\\big )} e^{-i 4\\pi(\\rho_{\\rm sc-cr}-\\rho_{l})/\\lambda}C_r\\big(2(\\rho-\\rho_{\\rm sc-cr})/c\\big)\n\\end{equation}\n\nwhere \n\n$\\rho_{\\rm sc-cr;}(s; s_{cr},\\rho_{cr}) = \\sqrt{(s-s_{cr})^2+\\rho_{cr}^2}$ is the distance from the spacecraft to the corner reflector,\n\n$\\theta_{az,cr} = \\sin^{-1} \\frac{s-s_{cr}}{\\rho_{\\rm sc-cr}}$ \n\nand\n\n$\\theta_{el,cr} = \\cos^{-1}\\frac{h_{sc}}{\\rho_{cr}}$\n\nand we have arbitrarily removed a large phase offset $4 \\pi \\rho_l / \\lambda$ to make the phase numbers more manageable. The rect function indicates that the chirp extent only covers the range defined by the pulse length. \n\n\n```python\ndef E_cr(sv,rhov,s_cr,rho_cr):\n rho_sc_cr = np.sqrt((sv-s_cr)**2+rho_cr**2)\n th_el_cr = np.arccos(h_sc/rho_cr)\n th_az_cr = np.arcsin((sv-s_cr)/rho_sc_cr)\n return np.sqrt(P_R) * S_p(th_az_cr,th_el_cr) * np.exp(-1j * 4. * np.pi * (rho_sc_cr-rho_l)/Lambda) * C_r_r (rhov-rho_sc_cr)\n\n```\n\nTo simulate the image, we must specify the location of the corner reflectors. First, we define the array of locations: 3 reflectors, each at different ranges and along-track positions. The along track positions will be at $s_0$ and a half beamwidth before and after $s_0$. The range position will be at the boresight range $\\rho_l$, and an eighth of the swath before and after $\\rho_l$. For the purpose of speed and flexibility, the simulation allows using any or all of the three corner reflectors through an index vector.\n\n$P_{\\rm cr} = \\big [\\big (s_{s,{\\rm hb}},\\rho_l-\\frac{\\rho_f-\\rho_n}{8}\\big),(s_0,\\rho_l),\\big(s_{e,{\\rm hb}},\\rho_l+\\frac{\\rho_f-\\rho_n}{8}\\big) \\big ]$\n \n\n\n```python\nS_cr = np.array([s_s_hb,s_0,s_e_hb],dtype='float64')\nRho_cr = np.array([rho_l-(rho_f-rho_n)/8.,rho_l,rho_l+(rho_f-rho_n)/8.],dtype='float64')\nInd_cr=[1]\n```\n\nNow it is time to define the grid for computing the simulated data; this will be over a portion range that covers the corner reflectors (to save computation time) and the along track extend define $s_{s,{\\rm sim}}$ and $s_{s,{\\rm sim}}$, which is specified in terms of the number of along-track beamwidths. The along track sample spacing is nominally set by the PRF $f_p$ as $\\Delta s = v_{sc}/f_p$. The range spacing is nominally set by the range bandwidth $\\Delta\\rho = c / 2B_R$. For both dimensions, we allow an oversampling factor so that we can easily examine the results without interpolating the results. \n\n\n```python\ns_ov = 1.\nrho_ov = 4.\nDelta_s = v_sc/f_p\nn_s_sim = int(np.round((s_e_sim-s_s_sim)*s_ov/Delta_s))\ns_sim = np.linspace(s_s_sim, s_e_sim, n_s_sim)\nrho_mean = (rho_f+rho_n)/2.\nrho_s_sim = rho_mean - (rho_f-rho_n)/4. # central half of swath\nrho_e_sim = rho_mean + (rho_f-rho_n)/4. # central half of swath\n#this is the default for range extent. We can narrow further to just surrounding the CRs\nRho_cr_min = rho_f\nRho_cr_max = rho_n\nfor i in range(len(Ind_cr)):\n Rho_cr_min=np.minimum(Rho_cr[Ind_cr[i]],Rho_cr_min)\nfor i in range(len(Ind_cr)):\n Rho_cr_max=np.maximum(Rho_cr[Ind_cr[i]],Rho_cr_max)\nrho_s_sim = Rho_cr_min - 4.* c* tau_r/2.\nrho_e_sim = Rho_cr_max + 4.* c* tau_r/2.\nn_rho_sim = int(np.round((rho_e_sim-rho_s_sim)*rho_ov/Delta_rho))\n\nrho_sim = np.linspace(rho_s_sim, rho_e_sim, n_rho_sim)\nS_sim, Rho_sim = np.meshgrid(s_sim,rho_sim)\n```\n\nLet's look at the corner reflectors on the grid: \n\n\n```python\nfig = plt.figure(figsize=(10, 7))\n\nplt.scatter(S_cr,Rho_cr, cmap='magma')\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Corner Reflector Locations\")\nplt.xlim(s_s_sim,s_e_sim)\nplt.ylim(rho_s_sim,rho_e_sim);\nplt.tight_layout()\n```\n\nWith the grid defined, we can simply evaluate $E_{cr}$ over the grid. \n\n\n```python\n%%time\nE_cr_sim = np.zeros(S_sim.shape,dtype=np.complex128)\nprint (\"Field initialized\")\nfor i in range(len(Ind_cr)):\n E_cr_sim += E_cr(S_sim,Rho_sim,S_cr[Ind_cr[i]],Rho_cr[Ind_cr[i]])\n print(\"Completed CR\",i)\n```\n\n\n```python\nfig = plt.figure(figsize=(12, 6))\n#plt.contourf(S_sim, Rho_sim, 10.*np.log10(np.absolute(E_cr_sim)), 20, cmap='RdGy')\n#plt.pcolormesh(S_sim, Rho_sim, 10.*np.log10(np.absolute(E_cr_sim)),cmap='RdGy')\nextent = [s_s_sim, s_e_sim, rho_s_sim, rho_e_sim]\nplt.imshow(10.*np.log10(np.abs(E_cr_sim)), cmap='magma', extent=extent, origin='lower', aspect='auto')\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Magnitude of Simulated Echoes\");\nplt.tight_layout()\n```\n\nNow let's look at these echoes in the presence of the thermal noise signature, with a field with noise power $k T B_r$.\n \n\n\n```python\nnp.random.seed(1)\nE_cr_sim_w_noise = E_cr_sim + np.random.normal(loc=0.,scale=np.sqrt(P_N/2.),size=S_sim.shape) + 1j * np.random.normal(loc=0.,scale=np.sqrt(P_N/2.),size=S_sim.shape)\nprint (\"Random field calculated\")\n```\n\n\n```python\nfig = plt.figure(figsize=(12, 6))\nplt.imshow(10.*np.log10(np.abs(E_cr_sim_w_noise)), cmap='magma', extent=extent, origin='lower', aspect='auto')\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Magnitude of Simulated Echoes with Noise\");\nplt.tight_layout()\n```\n\nAs can be seen, these signals are buried in the noise. They don't pop out until we focus the image, taking advantage of the redundancy in observing any single target over a wide beam in azimuth, and a wide pulse in range. So it is time to focus the data. \n\n# 3.0 Focusing SAR Data - Range\n\nThe straightforward approach to focusing data is to develop a means for any given target to compensate the phase variations in range and azimuth induced by the range chirp and the azimuth hyperbolic range variability and then sum up that energy. For the isolated corner reflector target responses shown above this is easy to visualize, in that we are plotting the magnitude. If the phase for each of these points was a constant value, it is easy to see that integrating the points in the non-zero areas would give a big integration gain. Of course if the phase were constant everywhere, one could not distinguish one corner reflector from any other, so there would be no integration advantage. Because the phase history in range and azimuth is unique for each scatterer on the ground, the process of compensating the phase for that specific point, then integrating the energy localizes the return from that specific point. This can be partitioned into the phase compensation and integration in range, called \"range compression,\" or \"range correlation,\" followed by azimuth processing. \n\n## 3.1 Range Correlation - time domain\n\n\nThe range signal that matches the range response received echo of a corner reflector, is simply \n\\begin{equation}\nC_r\\big(2(\\rho-\\rho_{\\rm sc-cr})/c\\big) = e^{i 4 \\pi \\frac{B_r}{c^2\\tau_r} (\\rho-\\rho_{\\rm sc-cr} )^2} {\\rm rect}\\big(\\frac{\\rho-\\rho_{\\rm sc-cr}}{c \\tau_r/2}\\big)\n\\end{equation}\n\nwhich is the same as the received echo $E_{cr}(s,\\rho; s_{cr}, \\rho_{cr})$ but without the propagation-related amplitude scale factor and phase components of the signal.\n\nTo recover the signal in range as a point, we would compute the conjugate function and integrate for each range point\n\n\n\\begin{equation}\nE_{cr,rc}(s,\\rho; s_{cr}, \\rho_{cr}) = \\displaystyle\\int E_{cr}(s,\\rho'; s_{cr}, \\rho_{cr}) C^*_r(s,\\rho'+\\rho; s_{cr}, \\rho_{cr}) d\\rho'\n\\end{equation}\n\nThis is by definition the cross correlation of these two functions. For corner reflector, this correlation integral can be evaluated\n\n$\n\\begin{array}{ll}\nE_{cr,rc} & = & \\sqrt{G_T} e^{-i 4\\pi(\\rho_{\\rm sc-cr}-\\rho_{l})/\\lambda} \\displaystyle\\int C_r(s,\\rho'; s_{cr}, \\rho_{cr}) C^*_r(s,\\rho'+\\rho; s_{cr}, \\rho_{cr}) d\\rho' \\\\\n& = & \\sqrt{G_T} e^{-i 4\\pi(\\rho_{\\rm sc-cr}-\\rho_{l})/\\lambda} \\displaystyle\\int e^{i 4 \\pi \\frac{B_r}{c^2\\tau_r} (\\rho'-\\rho_{\\rm sc-cr} )^2} {\\rm rect}\\big(\\frac{\\rho'-\\rho_{\\rm sc-cr}}{c \\tau_r/2}\\big) e^{-i 4 \\pi \\frac{B_r}{c^2\\tau_r} (\\rho'+\\rho-\\rho_{\\rm sc-cr} )^2} {\\rm rect}\\big(\\frac{\\rho'+\\rho-\\rho_{\\rm sc-cr}}{c \\tau_r/2}\\big) d\\rho' \\\\\n& = & \\sqrt{G_T} e^{-i 4\\pi(\\rho_{\\rm sc-cr}-\\rho_{l})/\\lambda} e^{i 4 \\pi \\frac{B_r}{c^2\\tau_r} (\\rho^2-\\rho_{\\rm sc-cr}^2)} \\displaystyle\\int e^{i 4 \\pi \\frac{B_r}{c^2\\tau_r} (\\rho'-\\rho_{\\rm sc-cr} )^2} {\\rm rect}\\big(\\frac{\\rho'-\\rho_{\\rm sc-cr}}{c \\tau_r/2}\\big) {\\rm rect}\\big(\\frac{\\rho'+\\rho-\\rho_{\\rm sc-cr}}{c \\tau_r/2}\\big) d\\rho'\n\\end{array}\n$\n \n\n\n```python\n%%time\nn_r = int(np.round(rho_ov * B_r * tau_r)) \nrho_c_ov = np.linspace(0.,c*tau_r/2.,n_r) # properly oversample to match simulation oversampling\nC_r_ref = C_r_r(rho_c_ov) # compute the properly oversampled reference function\nrange_shape=np.correlate(E_cr_sim[:,0],C_r_ref,mode='valid').shape[0] # perform one correlation to determine the length of the output\nE_cr_rc = np.zeros((range_shape,E_cr_sim.shape[1]),dtype=np.complex128) # initialize\nfor i in range(E_cr_sim.shape[1]): # correlate\n E_cr_rc[:,i] = np.correlate(E_cr_sim[:,i],C_r_ref,mode='valid')\n```\n\nHere is the range-correlated signal over the simulation domain. \n\n\n```python\nn_rho_rc = E_cr_rc.shape[0]\nrho_s_rc = rho_s_sim\nrho_e_rc = rho_sim[n_rho_rc-1]\nextent = [s_s_sim, s_e_sim, rho_s_rc, rho_e_rc]\nfig = plt.figure(figsize=(8, 6))\nplt.imshow(20.*np.log10(np.abs(E_cr_rc)), cmap='magma', extent=extent, origin='lower', aspect='auto',vmax=-100.,vmin=-200.)\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Power of Range Compressed Echoes - Using Time-domain Correlation\")\nplt.colorbar(label='Power (dB)');\n\n```\n\nLet's look at the range correlated output centered on the along-track position of the first corner reflector in the simulation list (may be different from the first defined depending on the index array above). \n\n\n```python\nind_s_cr=int(np.round((S_cr[Ind_cr[0]]-s_s_sim)*s_ov/Delta_s))\nind_rho_cr=int(np.round((Rho_cr[Ind_cr[0]]-rho_s_sim)*rho_ov/Delta_rho))\nE_cr_rc_1rl = E_cr_rc[:,ind_s_cr]\n```\n\n\n```python\nfig = plt.figure(figsize=(13, 5))\n\nax = fig.add_subplot(1,2,1)\nax.plot(rho_sim[0:E_cr_rc_1rl.shape[0]],20.*np.log10(np.abs(E_cr_rc_1rl)))\nax.set_title(\"Range Compressed Signal - One Range Line\")\nax.set_xlabel(\"Range (m)\")\nax.set_ylabel(\"Power\")\n\nax = fig.add_subplot(1,2,2)\nsr=ind_rho_cr-50\ner=ind_rho_cr+50\nax.plot(rho_sim[sr:er],20.*np.log10(np.abs(E_cr_rc[sr:er,ind_s_cr]))-np.max(20.*np.log10(np.abs(E_cr_rc[sr:er,ind_s_cr]))))\nax.set_title(\"Range Compressed Signal - One Range Line - One CR\")\nax.set_xlabel(\"Range (m)\")\nax.set_ylabel(\"Signal Power Relative to Peak\")\n\nplt.show();\nplt.tight_layout()\n```\n\n## 3.2 Range Correlation - frequency domain\n\n\nThis can also be accomplished with FFT-based circular convolution, and it runs considerably faster. To accomplish this most straightforwardly, we can create a version of the chirp that is the same length as the range vector; then when we take the FFT, both will be the same length. Subscript \"rl\" stands for \"range line.\" Subscript \"fd\" stands for \"frequency domain.\" First compute the reference function's spectrum: \n\n\n```python\nC_r_ref_rl = np.zeros(n_rho_sim) + 1j *np.zeros(n_rho_sim)\nC_r_ref_rl[0:n_r] = C_r_ref\nC_r_REF_rl = np.conjugate(np.fft.fft(C_r_ref_rl))\nfreq = np.fft.fftfreq(C_r_REF_rl.shape[-1])\nfig = plt.figure(figsize=(8, 5))\nplt.plot(freq,np.absolute(C_r_REF_rl))\nplt.xlabel(\"Frequency (inverse samples)\")\nplt.ylabel(\"Spectral Power\")\nplt.title(\"Power of Range Reference Function Spectrum\");\n```\n\nNow perform the correlation through circular convolution in the frequency domain. \n\n\n```python\n%%time\nE_cr_rc_fd = np.zeros((E_cr_sim.shape),dtype=np.complex128)\nfor i in range(E_cr_sim.shape[1]):\n E_cr_rc_fd[:,i] = np.fft.ifft(np.fft.fft(E_cr_sim[:,i])*C_r_REF_rl)\n```\n\n\n```python\nplt.style.use('seaborn-whitegrid')\n\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nextent = [s_s_sim, s_e_sim, rho_s_sim, rho_e_sim]\nplt.imshow(20.*np.log10(np.abs(E_cr_rc_fd)), cmap='magma', extent=extent, origin='lower', aspect='auto',vmax=-100.,vmin=-200.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Power of Range Compressed Echoes \\n Using FFT Correlation\");\n\nplt.subplot(1,2,2)\ntemp = 20.*np.log10(np.abs(E_cr_rc_fd[sr:er,int(np.round(E_cr_rc_fd.shape[1]/2))]))\nplt.plot(rho_sim[sr:er],temp - np.max(temp))\nplt.title(\"Range Compressed Signal \\n One Range Line - One CR - Using FFT Correlation\")\nplt.xlabel(\"Range (m)\")\nplt.ylabel(\"Signal Power Relative to Peak\");\nplt.tight_layout()\n#plt.show();\nfigname = \"RangeCompressed_FFT.png\"\nplt.savefig(figname, dpi=300, transparent='false')\n```\n\n\n
ASSIGNMENT #2 : Discuss Range Compression Result \n\n
Answer the following questions regarding the range-focused data set : \n\nQuestion 2.1 : Download and present this figure in your document. Provide a Figure caption describing what is shown in the two panels of this figure.Question 2.2 : The range compressed echo in the left panel shows how the range to the target is significantly changing as the sensor passes by the target along its orbit (range cell migration). Please zoom into the figure and provide a rough estimate for the range cell migration within the main beam of the antenna (main beam extents roughly from along-track position -15km to along-track position +15km. Please provide range cell migration in the units of [meters].Question 2.3 : Measure the achieved range resolution by zooming into the panel on the right and measure the width of the focused peak at the -3dB power position. Please provide your estimate for range resolution in the unit of [meters]. \n\n
\nNow that we understand the range correlation, it is time to do the same thing in the along-track, or azimuth direction. The complication in azimuth is that each target on the ground expresses its reflected energy at different ranges in each pulse. This can be seen easily in the 2d plots above where the bright return in the range compressed data from a single corner reflector \"migrates\" through the range as a function of azimuth position - called range migration. This is addressed typically in two ways:\n\n1. Correlate each point on the ground with its exact hyperbolic replica, calculable from the knowledge of the radar motion. This is called back-projection or time-domain processing, and can be quite computationally expensive.\n2. Approximate the time-domain approach by working in the frequency domain to compensate for the migration, then perform a circular convolution.\n\nWe'll take these two approaches one at a time. First let's do the frequency domain approach as it can be built step by step to illustrate the impacts of the approximations.\n \n\n## 4.1 Azimuth reference function \n\n\nFirst let's look at the signal in azimuth at the peak of the range response of the first corner reflector. \n\n\n```python\nrho_ind_cr = int(np.round((Rho_cr[Ind_cr[0]]-rho_s_sim)*rho_ov/Delta_rho))\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.title(\"Range Compressed Signal - One Azimuth Line - One CR\")\nplt.xlabel(\"Range (m)\")\nplt.ylabel(\"Signal Power\")\nplt.plot(s_sim,20.*np.log10(np.abs(E_cr_rc[rho_ind_cr,:])));\nplt.tight_layout()\n```\n\nThe power of the received signal from a corner reflector in azimuth should follow the antenna pattern, but instead the power at a fixed range has a plateau around the corner reflector, then diminishes in a oscillatory fashion. These oscillations are a consequence of the fact that the range from the spacecraft to the corner reflector is changing with $s$. When the range change is such that the peak of the response migrates out of the range bin, we will begin to see the sidelobes of the range response. The observed null would occur at the $s$ location at which the range changes by the distance in range to the first null of the range sidelobes, which is $\\Delta\\rho$. Thus\n\n$s_{null} = \\sqrt{(\\rho_{cr}+\\Delta\\rho)^2 - \\rho^2_{cr}}$\n \n\n\n```python\ns_null = np.sqrt((Rho_cr[Ind_cr[0]]+Delta_rho)**2-(Rho_cr[Ind_cr[0]])**2)\nprint('Azimuth null position due to range migration =',np.round(100.*s_null)/100.,'m')\n```\n\nwhich is about where it is observed in the figure above. Let's instead track the expected location of the peak in azimuth. This is accomplished by noting that\n\n$ \\rho(s) = \\sqrt{(s-s_{cr})^2+\\rho^2_{cr}}$\n\nWe can use this to look up the range for any give $s$ in the range compressed data. The left panel below shows the range hyperbola as a function of along-track position. The central panel shows then the signal power in the range compressed signal along this hyperbola, which now looks like the antenna pattern as one would expect, indicating we are tracking the range migration well. The phase along this curve should have a hyperbolic variation of phase across azimuth. The right panel plots this phase; it looks like a wrapped hyperbolic function, so all is well. This phase will be the basis for the azimuth reference function. \n\n\n```python\nfig = plt.figure(figsize=(13, 5))\n\nax = fig.add_subplot(1,3,1)\nrho_of_s = np.sqrt((s_sim-S_cr[Ind_cr[0]])**2 + Rho_cr[Ind_cr[0]]**2)\nax.plot(s_sim,rho_of_s)\nax.set_title(\"Range as a function of azimuth for \\n First CR\")\nax.set_xlabel(\"Azimuth (m)\")\nax.set_ylabel(\"Range (m)\")\n\nax = fig.add_subplot(1,3,2)\nind_rho_of_s = np.round((rho_of_s-rho_s_sim)*rho_ov/Delta_rho).astype(int)\nE_cr_rc_1az = np.zeros(n_s_sim) + 1j *np.zeros(n_s_sim)\nfor i_s in range(n_s_sim):\n E_cr_rc_1az[i_s] = E_cr_rc[ind_rho_of_s[i_s],i_s]\nax.plot(s_sim,20.*np.log10(np.abs(E_cr_rc_1az)))\nax.set_title(\"Range Compressed Signal \\n One Azimuth Line Following range \\n One CR\")\nax.set_xlabel(\"Azimuth (m)\")\nax.set_ylabel(\"Signal Power\")\n\nax = fig.add_subplot(1,3,3)\nss = int(n_s_sim/2)-100\nse = int(n_s_sim/2)+100\n\nax.set_title(\"Range Compressed Signal \\n One Azimuth Line Following range \\n One CR\")\nax.set_xlabel(\"Azimuth (m)\")\nax.set_ylabel(\"Phase (rad)\")\nax.plot(s_sim[ss:se],np.arctan2(np.imag(E_cr_rc_1az[ss:se]),np.real(E_cr_rc_1az[ss:se])));\nplt.tight_layout()\n```\n\n## 4.2 Azimuth Focusing - time domain\n\n### 4.2.1 Coarsest Approximation: Straight Time-domain Correlation with a Constant Reference Function\n\n\nThe idea here is to assume that the azimuth reference function is as simple and constant as the range reference function. In this case, we can just perform a simple time domain correlation in azimuth. This ignores range migration, and the variation in range migration magnitude as a function of range. For small synthetic apertures and coarse range resolution, this may be adequate. Let's see how bad it can be. Let's use the mid-range as our reference and calculate the azimuth response there over the synthetic aperture. We'll then use that single function to correlate each of the range bins in the simulated range compressed pulse sequence and see what happens.\n \n\n\n```python\n%%time\n\ns_s_sa = rho_l * np.tan(theta_sq-theta_L_a/2.) # half beamwidth, w/ squint, relative to s_im\ns_e_sa = rho_l * np.tan(theta_sq+theta_L_a/2.) # half beamwidth, w/ squint, relative to s_im\nn_s_sa = np.round((s_e_sa-s_s_sa)* s_ov/Delta_s).astype(int)\n\ns_sa = np.linspace(s_s_sa,s_e_sa,n_s_sa)\nrho_sa = np.sqrt(rho_l**2+(s_sa)**2)\nC_az_ref = np.exp(-1j*4.*np.pi*rho_sa/Lambda) # correlate of observed phase history\naz_shape=np.correlate(E_cr_rc[0,:],C_az_ref,mode='full').shape[0] # perform one correlation to determine the length of the output\nE_cr_rcac = np.zeros((E_cr_rc.shape[0],az_shape),dtype=np.complex128) # initialize\nfor i in range(E_cr_rc.shape[0]): # correlate\n E_cr_rcac[i,:] = np.correlate(E_cr_rc[i,:],C_az_ref,mode='full')\n```\n\n\n```python\n# starting s of correlation array will be extended by half the azimuth reference function length\nind_s_cr_ac=int(np.round((S_cr[Ind_cr[0]]-s_s_sim)*s_ov/Delta_s))+int(np.round(n_s_sa/2))\nind_rho_cr_ac=ind_rho_cr\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nextent = [s_s_sim-Delta_s*n_s_sa/2./s_ov, s_e_sim+Delta_s*n_s_sa/2./s_ov, rho_s_rc, rho_e_rc]\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac)), cmap='magma', extent=extent, origin='lower', aspect='auto')\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Power of Image - Using Correlation\");\n\nplt.subplot(1,2,2)\nplt.title(\"Power of Image - Using Correlation - Zoom\")\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac[ind_rho_cr_ac-250:ind_rho_cr_ac+250,ind_s_cr_ac-500:ind_s_cr_ac+500])), cmap='magma', origin='lower', aspect='auto')\nplt.colorbar(label='Power (dB)');\n\n#plt.show();\nplt.tight_layout()\n```\n\nNot exactly a perfect corner reflector response, but energy was certainly concentrated. Note also the extra energy focused at 1/4 and 3/4 of the distance across the image. These are azimuth ambiguities, where the energy present outside the main lobe of the antenna is focused at an amplitude attenuated by the antenna pattern. These should occur at the azimuth location where the next stationary phase point is in the aliased signal, which is dependent on the exact sampling rate relative to the phase rate of the signal. Their appearance at ~ +/- 21 km is about right. \n\n### 4.2.2 Next Coarsest Approximation: Straight Time-domain Correlation with a Range-variable Reference Function\n\n\nHere we emphasize the notion that the reference function varies with range. Even though we are not taking into account range migration, we have a better match to the phase at a given range. We calculate the range variable reference function as a matrix, and keep it handy for the circular convolution step to come. This is a little tricky since the limits of the synthetic aperture change with range and we want the convolutions to be consistently aligned across range. So we must first create an array of the same length in azimuth as the number of pulses, then populate the array accordingly.\n\nThe synthetic aperture extents vary with range, and need to take into account any azimuth squint. For a point at $(s_{im},\\rho_{im})$ observed with squint $\\theta_{sq}$, the range of closest approach of the spacecraft when the boresight intersects this point is given by\n\n$ \\rho_{ca} = \\rho_{im} \\cos\\theta_{sq}$ \n\nand the along-track position of this point relative to closest approach is\n\n$s_{ca} = \\rho_{ca} \\tan \\theta_{sq}$\n\nThe limits of the synthetic aperture then are given by the angle subtended around this squint angle:\n\n$s_{s,sa} = \\rho_{ca} \\tan (\\theta_{sq} - \\theta_{L_a}/2) \\qquad s_{e,sa} = \\rho_{ca} \\tan (\\theta_{sq} + \\theta_{L_a}/2)$\n\n$\\rho_{s,sa} = \\rho_{ca} / \\cos(\\theta_{sq}-\\theta_{L_a}/2) \\qquad \\rho_{e,sa} = \\rho_{ca} / \\cos(\\theta_{sq}+\\theta_{L_a}/2)$\n\nWith these limits, the task is now to fill an array with a full set of range-dependent reference functions. The tricky part is calculating the functions on a regular grid with limits that vary with range. There is a lot of indexing and limit checking consequently.\n \n\n\n```python\n# calculate closest approach range and azimuth position for squinted geometry\n\nrho_rc = rho_sim[0:n_rho_rc]\nrho_ca = rho_rc * np.cos(theta_sq)\ns_ca = rho_ca * np.tan(theta_sq)\n\n#define the synthetic aperture extents across range\n\ns_s_sa_v_rho = rho_ca * np.tan(theta_sq-theta_L_a/2.) # half beamwidth, w/ squint, relative to s_im\ns_e_sa_v_rho = rho_ca * np.tan(theta_sq+theta_L_a/2.) # half beamwidth, w/ squint, relative to s_im\nn_s_sa_v_rho = np.round((s_e_sa_v_rho-s_s_sa_v_rho)* s_ov/Delta_s).astype(int)\n\nrho_s_sa_v_rho = rho_ca / np.cos(theta_sq-theta_L_a/2)\nrho_e_sa_v_rho = rho_ca / np.cos(theta_sq+theta_L_a/2)\nn_rho_sa_v_rho = np.round((rho_e_sa_v_rho-rho_s_sa_v_rho)* s_ov/Delta_s).astype(int)\n\n# calculate the indices along track that define the limits for each range.\n\nind_s_s_sa_v_rho = np.round((s_s_sa_v_rho-s_0)/(Delta_s/s_ov)).astype(int)\nind_s_e_sa_v_rho = np.round((s_e_sa_v_rho-s_0)/(Delta_s/s_ov)).astype(int)\n```\n\n\n```python\n# to define the reference function array, find the maximum extent needed\n\nn_s_sa_v_rho = (ind_s_e_sa_v_rho-ind_s_s_sa_v_rho)+1\nn_s_sa_v_rho_max = np.max(n_s_sa_v_rho)\nind_s_s_sa_v_rho_min = np.min(ind_s_s_sa_v_rho)\nind_s_e_sa_v_rho_max = np.max(ind_s_e_sa_v_rho)\n\n# now calculate the reference function placed consistently in the oversized array\n\ns_s_sa = s_0 + ind_s_s_sa_v_rho*Delta_s/s_ov\ns_e_sa = s_0 + ind_s_e_sa_v_rho*Delta_s/s_ov\n\n# initialize the reference array\n\nC_az_ref = np.zeros((n_rho_rc,n_s_sa_v_rho_max),dtype=np.complex128)\n\n# populate the reference array\n\nfor i in range(n_rho_rc): \n s_sa = np.linspace(s_s_sa[i],s_e_sa[i],n_s_sa_v_rho[i])\n rho_sa = np.sqrt(rho_ca[i]**2+(s_sa)**2)\n ssind = ind_s_s_sa_v_rho[i]-ind_s_s_sa_v_rho_min\n seind = ind_s_e_sa_v_rho[i]-ind_s_s_sa_v_rho_min\n C_az_ref[i,ssind:seind+1] = np.exp(-1j*4.*np.pi*rho_sa/Lambda) # correlate of observed phase history\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nplt.imshow((np.abs(C_az_ref)), cmap='magma', origin='lower', aspect='auto')\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Azimuth Reference Function Image\");\n\nindc = int(np.round(C_az_ref.shape[1]/2.))\n\nplt.subplot(1,2,2)\nplt.imshow(np.arctan2(np.imag(C_az_ref[:,indc-200:indc+200]),np.real(C_az_ref[:,indc-200:indc+200])), origin='lower', aspect='auto')\nplt.colorbar(label='Phase (rad)');\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Phase of Azimuth Reference Function Image\");\n\nplt.tight_layout()\n```\n\nThe jittery appearance of this image is due to the fact that the phase reference is changing rapidly as a function of range, and given the sampling in range, the sampling is not regular relative to the phase wrapping rate. Therefore to see a smoother version of this image, one needs to unwrap the image. \n\n\n```python\n%%time\n\n# finally do the correlation\n\naz_shape=np.correlate(E_cr_rc[0,:],C_az_ref[0,:],mode='full').shape[0] # perform one correlation to determine the length of the output\nE_cr_rcac2 = np.zeros((n_rho_rc,az_shape),dtype=np.complex128) # initialize\nfor i in range(n_rho_rc): # correlate\n E_cr_rcac2[i,:] = np.correlate(E_cr_rc[i,:],C_az_ref[i,:],mode='full')\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nextent = [s_s_sim-Delta_s*n_s_sa_v_rho_max/2./s_ov, s_e_sim+Delta_s*n_s_sa_v_rho_max/2./s_ov, rho_s_rc, rho_e_rc]\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Power of Image - Using Correlation\")\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac2)), cmap='magma', extent=extent, origin='lower', aspect='auto',vmax=-40.,vmin=-80.)\nplt.colorbar(label='Power (dB)')\n\nplt.subplot(1,2,2)\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac2[ind_rho_cr_ac-250:ind_rho_cr_ac+250,ind_s_cr_ac-500:ind_s_cr_ac+500])), cmap='magma', origin='lower', aspect='auto',vmax=-40.,vmin=-80.)\nplt.colorbar(label='Power (dB)')\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Image - Using Correlation - Zoom\")\n\nplt.tight_layout()\n\n```\n\n## 4.3 Azimuth Focusing - frequency domain\n\n### 4.3.1 Preparation for Range Migration Correction\n\n\nNote we have three corner reflectors located at unique ranges and azimuth locations. It is a well known property of Fourier Transforms that a translation of position in one domain is equivalent to a phase ramp in the other domain.\n\n$ \\displaystyle\\int f(t+\\delta t) e^{-i \\omega t} dt = \\displaystyle\\int f(t') e^{-i \\omega (t'-\\delta t)} dt = F(\\omega)e^{i \\omega\\delta t} $\n\nTherefore, by performing the Fourier transform of the range-compressed pulses in the azimuth direction will align the range-migration history *as a function of Doppler Frequency* of all ground points at a given range. Therefore if we express range as a function of Doppler frequency, then we can map the energy along the range curve to a constant range, nominally the closest approach range for broadside imaging, but it could be any constant range. This will allow us to exploit the convolutional properties of Fourier transforms in the azimuth direction. \n\n\n```python\nE_cr_rc_azfd = np.zeros((E_cr_rc.shape),dtype=np.complex128)\n\nfor i in range(E_cr_rc.shape[0]): # correlate\n E_cr_rc_azfd[i,:] = np.fft.fft(E_cr_rc[i,:])\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.imshow(20.*np.log10(np.abs(E_cr_rc_azfd)), cmap='magma', origin='lower', aspect='auto',vmax=-60.,vmin=-100.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track Frequency (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Azimuth Spectrum \");\n\n```\n\n### 4.3.2 Next Coarsest Approximation: Frequency-domain Correlation with a Range-variable Reference Function; no Range Migration Correction\n\n\nNow that we are in the frequency domain, we perform the equivalent of the time domain correlation by also transforming the reference function matrix, multiplying, then inverse transforming. In the correlation line using FFTs, we have combined many operations in one line:\n\n* Shifting the Azimuth chirp by half its length to center it at 0 delay. This centers the convolution properly. (roll function) \n* Perform FFT of it to put it in the spectral domain (remember it changes with each range)\n* Multiply by the spectrum of the data at that range\n* Inverse FFT to bring it back to the time domain. \n \n\n\n```python\n%%time\n\n# the correlation by FFT; no range migration\n\nE_cr_rcac_fd = np.zeros((E_cr_rc.shape),dtype=np.complex128) # initialize\nC_az_REF_al = np.zeros(E_cr_rc.shape[1],dtype=np.complex128)\n\nfor i in range(n_rho_rc): # correlate\n C_az_REF_al = np.zeros(E_cr_rc.shape[1],dtype=np.complex128)\n C_az_REF_al[0:C_az_ref.shape[1]] = np.conjugate(C_az_ref[i,:])\n E_cr_rcac_fd[i,:] = np.fft.ifft(np.fft.fft(E_cr_rc[i,:])*\n np.fft.fft(np.roll(C_az_REF_al,\n -int(C_az_ref.shape[1]/2))))\n \n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nextent = [s_s_sim, s_e_sim, rho_s_rc, rho_e_rc]\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac_fd)), cmap='magma', extent=extent, origin='lower', aspect='auto',vmax=-40.,vmin=-80.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Power of Image - Using FFT Correlation\")\n\nplt.subplot(1,2,2)\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac_fd[ind_rho_cr-250:ind_rho_cr+250,ind_s_cr-500:ind_s_cr+500])), cmap='magma', origin='lower', aspect='auto',vmax=-40.,vmin=-80.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Image - Using FFt Correlation - Zoom\");\nplt.tight_layout()\n```\n\n### 4.3.3 Range Migration Correction\n\n\nNow in the Fourier domain in azimuth above, we can see that there is a migration of the brightness to larger range as frequency increases (zero is at the left and right edges of the above image). This will be the case independent of the number and azimuth location of the corner reflectors. They all collapse back to a migration curve centered on zero frequency at the appropriate range. If there is squint, the migration curve will still be centered on zero frequency, but there will only be energy in the portion of the spectrum dictated by the antenna beam. We can use the range-Doppler relationship to shift energy at a given Doppler frequency to its appropriate range bins. As described in Eq. (6)\n\n\\begin{equation}\n\\phi_{az}(s;\\rho_0,s_0) = -\\frac{4\\pi}{\\lambda} \\big(\\rho(s;\\rho_0,s_0) - \\rho_0\\big) = -\\frac{4\\pi}{\\lambda} \\bigg (\\sqrt{(s-s_0)^2+\\rho_0^2})- \\rho_0\\bigg)\n\\end{equation}\n\nNoting that in our specialized geometry $s=v_{sc} t$, the time derivative of $\\phi_{az}$ can be written\n\n\\begin{equation}\n\\omega_{az} = \\frac{\\partial}{\\partial t} \\phi_{az}(s;\\rho_0,s_0) = -\\frac{4\\pi}{\\lambda} \\cdot \\frac{1}{2}\\big ((s-s_0)^2+\\rho_0^2 \\big)^{-1/2}\\cdot 2(s-s_0) \\cdot v_{sc}\n\\end{equation}\n\nConsolidating terms, and noting that $(s-s_0)^2 = \\rho^2-\\rho_0^2$, the Doppler frequency in Hertz is:\n\n\\begin{equation}\nf_{hz,az} = \\frac{\\omega_{az}}{2\\pi} = -\\frac{2}{\\lambda} \\cdot \\frac{1}{\\rho} \\big (\\rho^2-\\rho_0^2\\big )^{1/2} \\cdot v_{sc}\n\\end{equation}\n\nor \n\n\\begin{equation}\nf^2_{hz,az} = -\\frac{4}{\\lambda^2} \\cdot \\frac{1}{\\rho^2} \\big (\\rho^2-\\rho_0^2\\big ) \\cdot v^2_{sc}\n\\end{equation}\n\nThis equation can be rearranged to solve for range as a function of doppler frequency:\n\n\\begin{equation}\n\\rho(f_{hz,az}) = \\rho_0 \\bigg (1-\\frac{\\lambda^2 f^2_{hz,az}}{4 v^2_{sc}}\\bigg)^{-1/2}\n\\end{equation}\n\nThis can be reduced by Taylor expansion to the more familiar expression:\n\n\\begin{equation}\n\\rho(f_{hz,az}) \\approx \\rho_0 \\bigg (1+\\frac{\\lambda^2 f^2_{hz,az}}{8 v^2_{sc}}\\bigg)\n\\end{equation}\n \n\n\nEquation (26) can be used to apply the correction in the azimuth frequency domain. For each Doppler Frequency bin, we need to differentially shift the range position of each point by a range dependent amount that brings all points on a migration curve to the same range bin. This will allow proper compression of the energy in azimuth with no range migration loss. \n\nBecause the Fourier Transform is on sampled data, the azimuth spectrum is circular, so if there is significant squint, we need to be careful to compute the range migration curve with respect to the beam edges in the Doppler domain. The reference range will be the range at beam center, $\\rho_{dc}$, not the closest approach range. The Doppler centroid as a function of range is given by\n\n\\begin{equation}\nf_{dc}(\\rho_{dc}) = \\frac{2 v_{sc}}{\\lambda} \\sin\\theta \\sin\\theta_{sq} = \\frac{2 v_{sc}}{\\lambda} \\sin\\bigg(\\cos^{-1}\\bigg(\\frac{h_{sc}}{\\rho_{dc}}\\bigg)\\bigg) \\sin\\theta_{sq}\n\\end{equation}\nand the limits in the azimuth spectrum where it has significant energy is:\n\n\\begin{equation}\nf_{dc,\\pm}(\\rho_{dc}) = f_{dc}(\\rho_{dc}) \\pm \\frac{f_{az,bw}}{2}\n\\end{equation}\n\nwhereas the locations where the azimuth spectrum of the signal would have wrap points relative to the centroid are given by:\n\n\\begin{equation}\nf_{dc,\\pm,f_s}(\\rho_{dc}) = f_{dc}(\\rho_{dc}) \\pm \\frac{f_s}{2}\n\\end{equation}\n\nNote that if there is a large squint, and the azimuth spectrum is critically sampled, then the indexing into the azimuth buffer is messy, because the wrap points must be computed in the circular array modulo the buffer length of the array, while the range migration curve must be computed in an absolute sense. Note also that the negative frequencies are in the upper half of the array, so once the index is calculated, it must be adjusted. If the azimuth spectrum is oversampled to begin with, one still must address the proper interpretation of positive and negative frequencies in the buffer, but wrapping of the spectrum would be avoided. For the sake if simplicity in this tutorial, we will assume that we don't need to address the spectral wrapping, i.e. that we are either at zero squint or the spectrum is oversampled. If this is not the case, the range migration correction will not be correct.\n \n\n\n```python\n# calculate centroid as a function of range\n\ndef f_dc(rho):\n return 2. * v_sc * np.sin(np.arccos(h_sc/rho)) * np.sin(theta_sq) / Lambda\n\nf_az_bw = v_sc * s_ov / Delta_s\n\n# determine the range of frequencies in the spectrogram and define the meshgrid\n# assumes that the spectrum array will be rotated to have -f_bw/2 at an array index if [0]\n\nf_im = np.linspace(-f_az_bw/2.,f_az_bw/2.,E_cr_rc.shape[1])\nF_im, Rho_rc = np.meshgrid(f_im,rho_rc)\n\n# calculate the ambiguity of each of the frequencies in the spectrogram and add it to the frequency of each bin\n\nF_abs = np.zeros((F_im.shape),dtype=np.int)\nF_abs = F_im + f_az_bw * np.round((f_dc(Rho_rc)-F_im)/ (v_sc * s_ov / Delta_s)) \n\n```\n\n\n```python\nplt.figure(figsize=(13, 5))\nplt.imshow(F_abs, cmap='magma', origin='lower', aspect='auto')\nplt.colorbar(label='Frequency (Hz)')\nplt.xlabel(\"Along track Spectrum bin (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Absolute Frequency at each Frequency in Spectrogram\");\n```\n\n\n```python\n# rotate the spectrum to work more easily in this domain\nE_cr_rc_azfd_shift = np.zeros((E_cr_rc_azfd.shape),dtype=np.complex128)\nfor i in range(E_cr_rc.shape[0]): # correlate\n E_cr_rc_azfd_shift[i,:] = np.fft.fftshift(E_cr_rc_azfd[i,:])\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.imshow(20.*np.log10(np.abs(E_cr_rc_azfd_shift)), cmap='magma', origin='lower', aspect='auto',vmax=-60.,vmin=-100.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track Frequency (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Rotated Azimuth Spectrum \");\n```\n\nNow that we have the absolute frequency calculated for each range, and the spectrum rotated to match it, we are a position to perform the range migration correction for each frequency.\n \n\n\n```python\nRho_rm = np.zeros((F_im.shape),dtype=np.int)\nRho_rm = Rho_rc * (np.cos(theta_sq) / np.sqrt(1.- Lambda**2 * F_abs**2/ (4. * v_sc**2)))\nRho_rm_nn = np.zeros((F_im.shape),dtype=np.complex128)\nRho_rm_nn = np.round((Rho_rm-rho_rc[0])*rho_ov/Delta_rho).astype(int)\n\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.imshow(Rho_rm_nn, cmap='magma', origin='lower', aspect='auto')\nplt.colorbar(label='Range Migration (pixel)');\nplt.xlabel(\"Along track Frequency (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Range Migration Shift\");\n```\n\nWe are now ready to use this range migration map to resample the spectrum. The spectral wrap cut (which will not appear in the zero squint geometry) presents a bookkeeping challenge. For this tutorial we simply ignore it and interpolate across it. This will introduce artifacts, but using a nearest neighbor interpolator will mitigate some of the edge effects. \n\n\n```python\n%%time\n\n# for each frequency, use sinc interpolator to move data in range.\nE_cr_rc_azfd_rm = np.zeros((E_cr_rc_azfd.shape),dtype=np.complex128)\nfor i in range(E_cr_rc_azfd_rm.shape[0]):\n for j in range(E_cr_rc_azfd_rm.shape[1]):\n E_cr_rc_azfd_rm[i,j] = E_cr_rc_azfd_shift[min(Rho_rm_nn[i,j],E_cr_rc_azfd_rm.shape[0]-1),j]\n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.imshow(20.*np.log10(np.abs(E_cr_rc_azfd_rm)), cmap='magma', origin='lower', aspect='auto',vmax=-60.,vmin=-100.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track Frequency (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Range-Migrated Azimuth Spectrum \");\n```\n\n### 4.3.4 Reference Function Application and Inverse Azimuth Transform to the Image\n\nIt clear that the energy has been migrated to constant range, which will should improve the correlation result. Let's see. \n\n\n```python\n# rotate the spectrum back to original position\nE_cr_rc_azfd_rm_shift = np.zeros((E_cr_rc_azfd.shape),dtype=np.complex128)\nfor i in range(E_cr_rc.shape[0]): # correlate\n E_cr_rc_azfd_rm_shift[i,:] = np.fft.fftshift(E_cr_rc_azfd_rm[i,:])\n```\n\n\n```python\n%%time\n\n# the correlation by FFT; with range migration\n\nE_cr_rcac_fd_rm = np.zeros((E_cr_rc.shape),dtype=np.complex128) # initialize\nC_az_REF_al = np.zeros(E_cr_rc.shape[1],dtype=np.complex128)\n\nfor i in range(n_rho_rc): # correlate\n C_az_REF_al = np.zeros(E_cr_rc.shape[1],dtype=np.complex128)\n C_az_REF_al[0:C_az_ref.shape[1]] = np.conjugate(C_az_ref[i,:])\n E_cr_rcac_fd_rm[i,:] = np.fft.ifft(E_cr_rc_azfd_rm_shift[i,:]*\n np.fft.fft(np.roll(C_az_REF_al,\n -int(C_az_ref.shape[1]/2))))\n \n```\n\n\n```python\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nextent = [s_s_sim, s_e_sim, rho_s_rc, rho_e_rc]\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac_fd_rm)), cmap='magma', extent=extent, origin='lower', aspect='auto',vmax=-40.,vmin=-80.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (m)\")\nplt.ylabel(\"Range Position (m)\")\nplt.title(\"Power of Image - Using FFT Correlation with RM\");\n\nplt.subplot(1,2,2)\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac_fd_rm[ind_rho_cr-250:ind_rho_cr+250,ind_s_cr-500:ind_s_cr+500])), cmap='magma', origin='lower', aspect='auto',vmax=-40.,vmin=-80.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Image - Using FFT Correlation with RM - Zoom\")\nplt.tight_layout()\n```\n\n\n```python\nplt.figure(figsize=(10, 8))\nplt.imshow(20.*np.log10(np.abs(E_cr_rcac_fd_rm[ind_rho_cr-100:ind_rho_cr+100,ind_s_cr-50:ind_s_cr+50])), cmap='magma', origin='lower', aspect='auto',vmax=-30.,vmin=-70.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Image - Using FFT Correlation - Zoom\");\nfigname = \"FocusedinclRCM_FFT.png\"\nplt.savefig(figname, dpi=300, transparent='false')\n```\n\n### 4.3.5 Measuring Achieved Range and Azimuth Resolution\n\nIn the following code cell we create plots of the focused corner reflector along azimuth and range. Based on these cuts, the achieved azimuth and range resolution can be measured. \n\n\n```python\nazimuthcut = 20.*np.log10(np.abs(E_cr_rcac_fd_rm[ind_rho_cr,ind_s_cr-50:ind_s_cr+50]))\nrangecut = 20.*np.log10(np.abs(E_cr_rcac_fd_rm[ind_rho_cr-50:ind_rho_cr+50,ind_s_cr]))\n\nplt.figure(figsize=(13, 6))\nplt.subplot(1,2,1)\nplt.plot(S_sim[ind_rho_cr,ind_s_cr-50:ind_s_cr+50], azimuthcut-np.max(azimuthcut))\nplt.title(\"Focused Image \\n Cut through CR along Azimuth\")\nplt.xlabel(\"Azimuth (m)\")\nplt.ylabel(\"Signal Power\");\nplt.subplot(1,2,2)\nplt.plot(Rho_sim[ind_rho_cr-50:ind_rho_cr+50,ind_s_cr], rangecut-np.max(rangecut))\nplt.title(\"Focused Image \\n Cut through CR along Range\")\nplt.xlabel(\"Range (m)\")\nplt.ylabel(\"Signal Power\");\nplt.tight_layout()\n#plt.show();\n#figname = \"RangeCompressed_FFT.png\"\n#plt.savefig(figname, dpi=300, transparent='false')'''\n```\n\nAs can be seen, the energy is much better focused with range migration correction than without. The noise structure in the sidelobes is due to the poor nearest neighbor interpolator in azimuth migration. This would be improved with a better interpolator, since as a sinc interpolator. The sinc interpolator included in this notebook runs very slowly, however. \n\n\n
ASSIGNMENT #3 : Discussed Fully-Focused Image \n\n
Answer the following questions regarding the fully-focused data set : \n\nQuestion 3.1 : Download and present Figures 25 and 26 in your document. Provide figure captions describing what is shown in the respective figures.Question 3.2 : Measure the achieved azimuth resolution by zooming into the left panel in the above figure and measure the width of the focused peak at the -3dB power position. Please provide your estimate for azimuth resolution in the unit of [meters]. Additionally, please compare your measurement to the azimuth resolution numbers quoted in Section 1.5.Question 3.3 : Measure the achieved range resolution by zooming into the panel on the right and measure the width of the focused peak at the -3dB power position. Please provide your estimate for range resolution in the unit of [meters]. Additionally, please compare your measurement to the theoretical range resolution you calculated in Assignment 1. \n\n
\n The next Section is Optional : \n\n the next section of the notebook performs SAR focusing using a backprojection processing approach. In this approach, two-dimensional reference functions for each resolution cell are calculated followed by a focusing step using time-domain correlation. This is the most accurate method of SAR image focusing but also the most time consuming. \n \nNote : Running this next step will take approximately 1 hour.\n \n
\n\n\nThe range compressed response of a corner reflector was described above as:\n\n\\begin{equation}\nE_{cr,rc}(s,\\rho; s_{cr}, \\rho_{cr}) = K \\sqrt{G_T} e^{-i 4\\pi(\\rho_{\\rm sc-cr}-\\rho_{l})/\\lambda} {\\rm sinc}\\big(\\frac{\\rho-\\rho_{\\rm sc-cr}}{\\Delta\\rho}\\big)\n\\end{equation}\n\nwhere $\\rho_{\\rm sc-cr}$ would be the appropriate range for when the point was observed (including squint), and $s_cr$ the corresponding azimuth position. Let's focus on the complex hyperbolic phase that we explored above when discussing the phase history of a point over time.\n\n\\begin{equation}\nE_{cr,rc}(s,\\rho; s_{cr}, \\rho_{cr}) = K \\sqrt{G_T} e^{-i 4\\pi\\big(\\sqrt{(s-s_{cr})^2+\\rho_{cr}^2}-\\rho_{l}\\big)/\\lambda} {\\rm sinc}\\big(\\frac{\\rho-\\rho_{\\rm sc-cr}}{\\Delta\\rho}\\big)\n\\end{equation}\n\nIf we generalize $s_{cr}, \\rho_{cr}$ to any image point $[s_i,\\rho_i]$, this relationship of range to azimuth remains:\n\n\\begin{equation}\n\\rho (s) = \\sqrt{(s-s_i)^2+\\rho_i^2}\n\\end{equation}\n\nIn our idealized geometry, with the spacecraft flying a straight line above a flat earth, $\\rho_i$ is not a function of $s_i$ (no topography, no variable distance from orbit to ground), so $\\rho(s)$ is the same function for any $s_i$ at a given $\\rho_i$, but varies with $\\rho_i$.\n\nTherefore, to gather the energy in azimuth to focus the image at point $(s_i,\\rho_i)$, we simply look up the sample in the range compressed echoes corresponding for each $s$ and $\\rho$ in the synthetic aperture, compensate the propagation phase delay at each point, then sum all points in the synthetic aperture. Since the sample points are not necessarily perfectly aligned, we would ideally interpolate the echoes to get the exact values at $(s,\\rho)$. However, for the purpose of this tutorial, we will just take the nearest neighbor echo sample. First we define the image grid to be smaller than the simulation grid sufficiently to avoid edge effects.\n \n\n\n```python\n# define the image grid - trim relative to simulation\n# in range, trim by pulse duration\n\nrho_s_im = rho_s_sim + c * tau_r/2.\nrho_e_im = rho_e_sim - c * tau_r/2.\nn_rho_im = int(np.round((rho_e_im-rho_s_im)* rho_ov/Delta_rho))\nrho_im = np.linspace(rho_s_im,rho_e_im,n_rho_im)\n\n# in azimuth, trim by half a beamwidth\ns_s_im = s_s_sim + rho_f * theta_L_a / 2.\ns_e_im = s_e_sim - rho_f * theta_L_a / 2. \nn_s_im = int(np.round((s_e_im-s_s_im)* s_ov/Delta_s)) \ns_im = np.linspace(s_s_im,s_e_im,n_s_im)\nS_im, Rho_im = np.meshgrid(s_im,rho_im)\n```\n\nNext define the synthetic aperture extents. These vary with range, and need to take into account any azimuth squint. We did this above when defining the azimuth reference function for the correlation approach. Once again, for a point at $(s_{im},\\rho_{im})$ observed with squint $\\theta_{sq}$, the range of closest approach of the spacecraft when the boresight intersects this point is given by\n\n$ \\rho_{ca} = \\rho_{im} \\cos\\theta_{sq}$ \n\nand the along-track position of this point relative to closest approach is\n\n$s_{ca-rel} = \\rho_{ca} \\tan \\theta_{sq}$\n\nThe limits of the synthetic aperture then are given by the angle subtended around this squint angle:\n\n$s_{s,sa} = \\rho_{ca} \\tan (\\theta_{sq} - \\theta_{L_a}/2) \\qquad s_{e,sa} = \\rho_{ca} \\tan (\\theta_{sq} + \\theta_{L_a}/2)$\n\n$\\rho_{s,sa} = \\rho_{ca} / \\cos(\\theta_{sq}-\\theta_{L_a}/2) \\qquad \\rho_{e,sa} = \\rho_{ca} / \\cos(\\theta_{sq}+\\theta_{L_a}/2)$\n \n\n\n```python\n# define the synthetic aperture extents across range\n# first the closest approach range and azimuth for a given squinted slant range\nrho_ca = rho_im * np.cos (theta_sq)\ns_carel = rho_ca * np.tan(theta_sq)\n\n# Next the start and end extents for each of these points relative to s_im\ns_s_sa = rho_ca * np.tan(theta_sq-theta_L_a/2.) # half beamwidth, w/ squint, relative to s_im\ns_e_sa = rho_ca * np.tan(theta_sq+theta_L_a/2.) # half beamwidth, w/ squint, relative to s_im\nn_s_sa = np.round((s_e_sa-s_s_sa)* s_ov/Delta_s).astype(int)\n\nrho_s_sa = rho_ca / np.cos(theta_sq-theta_L_a/2)\nrho_e_sa = rho_ca / np.cos(theta_sq+theta_L_a/2)\nn_rho_sa = np.round((rho_e_sa-rho_s_sa)* s_ov/Delta_s).astype(int)\n```\n\nFor a given image point, $(s_{im},\\rho_{im})$ in the image of points $[s_{im},\\rho_{im}]$, coordinates over which to integrate the echoes are $(s,\\rho(s)) = (s,\\sqrt{(s-s_{im})^2+\\rho^2_{im}})$. Thus the time domain back projection processing will be\n\\begin{equation}\nE_{cr,td}(s_{im},\\rho_{im}) = \\displaystyle \\int_{s_{im}+s_{s,sa}}^{s_{im}+s_{e,sa}} E_{cr,rc}(s,\\rho(s)) e^{i 4 \\pi \\rho(s) /\\lambda} ds\n\\end{equation}\n\nwith $s_{s,sa}$ and $s_{e,sa}$ defined above as image point-relative extents of the synthetic aperture. Note we can get away with calculating the $\\rho(s)$ function once per range bin because of the regular rectilinear motion with no topography. You will rapidly find if you execute the next block that it takes *forever* due to the triple loop and the python-interpreted indexing. You will need to interrupt the run to uncomment the limits specified around each of the corner reflectors to perform only the necessary calculations. \n\n\n```python\n%%time\n\nE_cr_im = np.zeros((n_rho_im,n_s_im),dtype=np.complex128) # initialize output grid\n\n# Calculate computable limits +/- 200 m\nbp_win = 200.\n#\nns_s_im_cr = np.round((S_cr - bp_win - s_s_im)*s_ov/Delta_s).astype(int)\nne_s_im_cr = np.round((S_cr + bp_win - s_s_im)*s_ov/Delta_s).astype(int)\nns_rho_im_cr = np.round((Rho_cr - bp_win - rho_s_im)*rho_ov/Delta_rho).astype(int)\nne_rho_im_cr = np.round((Rho_cr + bp_win - rho_s_im)*rho_ov/Delta_rho).astype(int)\nfor ncr in range(len(Ind_cr)):\n print (\"Reflector \",Ind_cr[ncr],ns_s_im_cr[Ind_cr[ncr]],\n ne_s_im_cr[Ind_cr[ncr]],ns_rho_im_cr[Ind_cr[ncr]],ne_rho_im_cr[Ind_cr[ncr]])\n\n for rho_im_b in range(ns_rho_im_cr[Ind_cr[ncr]],ne_rho_im_cr[Ind_cr[ncr]]):\n if(np.mod(rho_im_b,10)==0): print (rho_im_b)\n s_sa = np.linspace(s_s_sa[rho_im_b],s_e_sa[rho_im_b],n_s_sa[rho_im_b])\n rho_sa = np.sqrt(rho_im[rho_im_b]**2+(s_sa)**2)\n azref = np.exp(1j*4.*np.pi*rho_sa/Lambda) # conjugate of observed phase history\n for s_im_b in range(ns_s_im_cr[Ind_cr[ncr]],ne_s_im_cr[Ind_cr[ncr]]):\n E_cr_rc_bp=np.zeros(n_s_sim,dtype=np.complex128)\n azref_bp=np.zeros(n_s_sim,dtype=np.complex128)\n for sb in range(len(s_sa)):\n sb_rc = int(np.round((s_im[s_im_b]+s_sa[sb]-s_s_sim)*s_ov/Delta_s))\n rhob_rc = int(np.round((rho_sa[sb]-rho_s_sim)*rho_ov/Delta_rho))\n E_cr_rc_bp[sb_rc]=E_cr_rc[rhob_rc,sb_rc]\n azref_bp[sb_rc]=azref[sb]\n E_cr_im[rho_im_b,s_im_b] += np.dot(E_cr_rc_bp,azref_bp)\n```\n\n\n```python\nplt.figure(figsize=(8, 5))\nplt.imshow(20.*np.log10(np.abs(E_cr_im[ns_rho_im_cr[Ind_cr[ncr]]:ne_rho_im_cr[Ind_cr[ncr]],ns_s_im_cr[Ind_cr[ncr]]:ne_s_im_cr[Ind_cr[ncr]]])), cmap='magma', origin='lower', aspect='auto',vmax=-30.,vmin=-70.)\nplt.colorbar(label='Power (dB)');\nplt.xlabel(\"Along track position (pixel)\")\nplt.ylabel(\"Range Position (pixel)\")\nplt.title(\"Power of Image - Using Time Domain Back Projection\");\n```\n\n# Summary\n\n\n This tutorial covers the following topics:\n\n* SAR Geometry\n* Antenna Patterns\n* The Radar Equation\n* Doppler and Phase in the synthetic aperture\n* Range reference function and correlation to achieve fine range resolution\n - Range correlation in the time domain \n - Range correlation using FFTs to perform circular correlation\n* Azimuth reference function and correlation \n - Azimuth correlation in the time domain \n - Azimuth migration correction\n - Azimuth correlation using FFTs to perform circular correlation\n - Backprojection in the time domain\n \nWhile the geometry is idealized, through this step-by-step approach with python code to simulate radar echoes from point targets and a variety of methods to process the data, the notebook illustrates the meaning of the synthetic aperture, the explicit signal properties of the return echoes, and how the varying range of a target from pulse to pulse necessitates a some resampling to align the energy with a regular grid. \n\nThe notebook is designed to allow the student to adjust parameters to alter resolution, squint, geometry, radar elements such as antenna dimensions, and other factors. Some of these can be done locally, others must be done at the beginning of the notebook. Once the student is familiar with the cell dependencies, these will become clear. For example, resolution of the simulation and other geometric parameters must be set at the beginning. Plot dimensions, and processing choices once the simulation is established can be set locally. A successful learning outcome would be confidence in understanding where parameters need to change to affect the tutorial in a particular way. \n \n", "meta": {"hexsha": "a416c62279656207752e6dd70324c57cc9ff63a9", "size": 132481, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "2021/GEOS 657-Lab3-SARProcessing.ipynb", "max_stars_repo_name": "uafgeoteach/GEOS657_MRS", "max_stars_repo_head_hexsha": "682d9d936e058c692d3f3f1492c243e569cd0f6f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-11-02T04:02:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T20:44:53.000Z", "max_issues_repo_path": "2021/GEOS 657-Lab3-SARProcessing.ipynb", "max_issues_repo_name": "uafgeoteach/GEOS657_MRS", "max_issues_repo_head_hexsha": "682d9d936e058c692d3f3f1492c243e569cd0f6f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2021/GEOS 657-Lab3-SARProcessing.ipynb", "max_forks_repo_name": "uafgeoteach/GEOS657_MRS", "max_forks_repo_head_hexsha": "682d9d936e058c692d3f3f1492c243e569cd0f6f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-11-30T16:12:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T20:02:33.000Z", "avg_line_length": 37.9167143675, "max_line_length": 1217, "alphanum_fraction": 0.5968101086, "converted": true, "num_tokens": 25387, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46101677931231594, "lm_q2_score": 0.31742626558767584, "lm_q1q2_score": 0.14633883463036615}}
{"text": "\n\n## Live Lecture - Deriving Bayes' Theorem, Calculating Bayesian Confidence\n\nNotice that $P(A|B)$ appears in the above laws - in Bayesian terms, this is the belief in $A$ updated for the evidence $B$. So all we need to do is solve for this term to derive Bayes' theorem. Let's do it together!\n\n\n```\n# Activity 2 - Use SciPy to calculate Bayesian confidence intervals\n# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bayes_mvs.html#scipy.stats.bayes_mvs\n```\n\n\n```\nfrom scipy import stats\nimport numpy as np\n\n# Set Random Seed for Reproducibility\nnp.random.seed(seed=42)\n\ncoinflips = np.random.binomial(n=1, p=.5, size=10)\nprint(coinflips)\n```\n\n\n```\ndef confidence_interval(data, confidence=.95):\n n = len(data)\n mean = sum(data)/n\n data = np.array(data)\n stderr = stats.sem(data)\n interval = stderr * stats.t.ppf((1 + confidence) / 2.0, n-1)\n return (mean , mean-interval, mean+interval)\n\nconfidence_interval(coinflips)\n```\n\n\n```\nbayes_mean_CI, _, _ = stats.bayes_mvs(coinflips, alpha=.95)\n \nbayes_mean_CI\n```\n\n\n```\n??stats.bayes_mvs\n```\n\n\n```\ncoinflips_mean_dist.rvs(1000)\n```\n\n## Assignment - Code it up!\n\nMost of the above was pure math - now write Python code to reproduce the results! This is purposefully open ended - you'll have to think about how you should represent probabilities and events. You can and should look things up, and as a stretch goal - refactor your code into helpful reusable functions!\n\nSpecific goals/targets:\n\n1. Write a function `def prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk)` that reproduces the example from lecture, and use it to calculate and visualize a range of situations\n2. Explore `scipy.stats.bayes_mvs` - read its documentation, and experiment with it on data you've tested in other ways earlier this week\n3. Create a visualization comparing the results of a Bayesian approach to a traditional/frequentist approach\n4. In your own words, summarize the difference between Bayesian and Frequentist statistics\n\nIf you're unsure where to start, check out [this blog post of Bayes theorem with Python](https://dataconomy.com/2015/02/introduction-to-bayes-theorem-with-python/) - you could and should create something similar!\n\nStretch goals:\n\n- Apply a Bayesian technique to a problem you previously worked (in an assignment or project work) on from a frequentist (standard) perspective\n- Check out [PyMC3](https://docs.pymc.io/) (note this goes beyond hypothesis tests into modeling) - read the guides and work through some examples\n- Take PyMC3 further - see if you can build something with it!\n\n\n```\nimport random\nimport matplotlib.pyplot as plt\nimport numpy as np\nfrom scipy import stats\n```\n\n\n```\n\ndef prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk):\n return (prob_positive_drunk*prob_drunk_prior) / prob_positive\n```\n\n\n```\nprob_drunk_given_positive(0.001, 0.08, 1)\n```\n\n\n\n\n 0.0125\n\n\n\n\n```\nlist1 = []\nfor i in range(100):\n \n num = prob_drunk_given_positive(random.uniform(0.001, 0.003), \n random.uniform(0.06, 0.1),\n random.uniform(0.95, 1))\n list1.append(num)\n \n \nplt.scatter(range(100),list1);\nplt.xlabel('Trial run number');\nplt.ylabel('Probability');\n```\n\n\n```\ncoinflips_100 = np.random.binomial(n=1, p=.5, size=100)\n\nsample_std = np.std(coinflips_100)\nsample_size = len(coinflips_100)\nstandard_error = sample_std / (sample_size**(.5))\nt = stats.t.ppf(.975 , sample_size-1)\nsample_mean = coinflips_100.mean()\nconfidence_interval = (sample_mean - t*standard_error, sample_mean + t*standard_error)\n\nbayes_mean_CI, _, _ = stats.bayes_mvs(coinflips_100, alpha=.95)\nprint(bayes_mean_CI)\n```\n\n Mean(statistic=0.54, minmax=(0.4406089327527315, 0.6393910672472686))\n\n\n\n```\nimport seaborn as sns\n\nsns.kdeplot(coinflips_100)\nplt.axvline(x=confidence_interval[0], color='red')\nplt.axvline(x=confidence_interval[1], color='red')\nplt.axvline(x=sample_mean, color='k');\nplt.title(\"Frequentist Approach\");\n\n```\n\n\n```\nsns.kdeplot(coinflips_100)\nplt.axvline(x=bayes_mean_CI[1][0], color='red')\nplt.axvline(x=bayes_mean_CI[1][1], color='red')\nplt.axvline(x=sample_mean, color='k');\nplt.title(\"Bayesian Approach\");\n```\n\nBayesian Statistics deals with probability and uncertainty in a broader spectrum of events. Although the events that are tested may not be reproducible, Bayes stats works to still find a numerical value/probability to place on the event. It also uses prior probabilities in the calculation of new ones, which is criticized by frequentists.\n\nFrequentist statistics employs the use of confidence intervals and p-values to explain the probability of events. These events are more than likely repeatable and give a more accurate look into long-term occurences. Frequentists like having more concrete values before making any assertions and \n\n## Resources\n\n- [Worked example of Bayes rule calculation](https://en.wikipedia.org/wiki/Bayes'_theorem#Examples) (helpful as it fully breaks out the denominator)\n- [Source code for mvsdist in scipy](https://github.com/scipy/scipy/blob/90534919e139d2a81c24bf08341734ff41a3db12/scipy/stats/morestats.py#L139)\n", "meta": {"hexsha": "7e68853de89545e872d10f356406abde4bb4c9a0", "size": 72957, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LS_DS_133_Introduction_to_Bayesian_Inference.ipynb", "max_stars_repo_name": "justin-hsieh/DS-Unit-1-Sprint-3-Statistical-Tests-and-Experiments", "max_stars_repo_head_hexsha": "8df28a369a1b282dead1dede3c6b97ab6393d094", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "LS_DS_133_Introduction_to_Bayesian_Inference.ipynb", "max_issues_repo_name": "justin-hsieh/DS-Unit-1-Sprint-3-Statistical-Tests-and-Experiments", "max_issues_repo_head_hexsha": "8df28a369a1b282dead1dede3c6b97ab6393d094", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "LS_DS_133_Introduction_to_Bayesian_Inference.ipynb", "max_forks_repo_name": "justin-hsieh/DS-Unit-1-Sprint-3-Statistical-Tests-and-Experiments", "max_forks_repo_head_hexsha": "8df28a369a1b282dead1dede3c6b97ab6393d094", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 141.1160541586, "max_line_length": 20304, "alphanum_fraction": 0.8459914744, "converted": true, "num_tokens": 2802, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3174262655876759, "lm_q2_score": 0.4610167793123159, "lm_q1q2_score": 0.14633883463036615}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n#####Version 0.1\nWelcome to *Bayesian Methods for Hackers*. The full Github repository, and additional chapters, is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are a Bayesian practitioner! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n\n###The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty* about our beliefs. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist* methods assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these universes, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is clear how we can speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate A will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either heads or tails. Now what is *your* belief that the coin is heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true. Though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease.\n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial evidence. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$.:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being heads. $P(A | X):\\;\\;$ You look at the coin, observe a heads has landed, denote this information $X$, and trivially assign probability 1.0 to heads and 0.0 to tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*.\n\n\n\n###Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: a probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n####Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of stastical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computational-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools like Least Squares linear regression, LASSO regression, EM algorithm etc. are all very powerful and incredibly fast. Bayesian methods are a compliment to solve the problems these solutions cannot or to gain further insight into the underlying system by offering more flexibility in modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\" )\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after it's discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to } )\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for matplotlib plots.\nIf executing this book, and you wish to use the book's styling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the book's styles/ dir.\n See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to update the styles\n in only this notebook. Try running the following code:\n\n import json\n s = json.load( open(\"../styles/bmh_matplotlibrc.json\") )\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n#the code below can be passed over, as it is currently not important.\n%pylab inline\nfigsize( 11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0,1,2,3,4,5,8,15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size = n_trials[-1] )\nx = np.linspace(0,1,100)\n\nfor k, N in enumerate(n_trials):\n sx = subplot( len(n_trials)/2, 2, k+1)\n \n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads )\n plt.plot( x, y, label= \"observe %d tosses,\\n %d heads\"%(N,heads) )\n plt.fill_between( x, 0, y, color=\"#348ABD\", alpha = 0.4 )\n plt.vlines( 0.5, 0, 4, color = \"k\", linestyles = \"--\", lw=1 )\n \n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight = True)\n\n\nplt.suptitle( \"Bayesian updating of posterior probabilities\", \n y = 1.02,\n fontsize = 14);\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our confidence is proportional to the height of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will lump closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5. As more data accumulates, we would see more and more probability being assigned at $p=0.5$.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n#####Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```\nfigsize(12.5,4)\np = np.linspace( 0,1, 50)\nplt.plot( p, 2*p/(1+p), color = \"#348ABD\", lw = 3 )\n#plt.fill_between( p, 2*p/(1+p), alpha = .5, facecolor = [\"#A60628\"])\nplt.scatter( 0.2, 2*(0.2)/1.2, s = 140, c =\"#348ABD\" )\nplt.xlim( 0, 1)\nplt.ylim( 0, 1)\nplt.xlabel( \"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title( \"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a graph of both the prior and the posterior probabilities. \n\n\n\n```\nfigsize( 12.5, 4 )\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar( [0,.7], prior ,alpha = 0.70, width = 0.25, \\\n color = colours[0], label = \"prior distribution\",\n lw = \"3\", edgecolor = colours[0])\n\n\nplt.bar( [0+0.25,.7+0.25], posterior ,alpha = 0.7, \\\n width = 0.25, color = colours[1], \n label = \"posterior distribution\",\n lw = \"3\", edgecolor = colours[1])\n\nplt.xticks( [0.20,.95], [\"Bugs Absent\", \"Bugs Present\"] )\nplt.title(\"Prior and Posterior probability of bugs present, prior = 0.2\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n##Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n###Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\nWhat is $\\lambda$? It is called the parameter, and it describes the shape of the distribution. For the Poisson random variable, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. Unlike $\\lambda$, which can be any positive number, $k$ must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne very useful property of the Poisson random variable, given we know $\\lambda$, is that its expected value is equal to the parameter, ie.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's something useful to remember. Below we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$ we add more probability to larger values occurring. Secondly, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```\nfigsize( 12.5, 4)\n\nimport scipy.stats as stats\na = np.arange( 16 )\npoi = stats.poisson\nlambda_ = [1.5, 4.25 ]\n\nplt.bar( a, poi.pmf( a, lambda_[0]), color=colours[0],\n label = \"$\\lambda = %.1f$\"%lambda_[0], alpha = 0.60,\n edgecolor = colours[0], lw = \"3\")\n\nplt.bar( a, poi.pmf( a, lambda_[1]), color=colours[1],\n label = \"$\\lambda = %.1f$\"%lambda_[1], alpha = 0.60,\n edgecolor = colours[1], lw = \"3\")\n\nplt.xticks( a + 0.4, a )\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n###Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with a *exponential density*. The density function for an exponential random variable looks like:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike the Poisson random variable, an exponential random variable can only take on non-negative values. But unlike a Poisson random variable, the exponential can take on *any* non-negative values, like 4.25 or 5.612401. This makes it a poor choice for count data, which must be integers, but a great choice for time data, or temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. Below are two probability density functions with different $\\lambda$ value. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```\na = np.linspace(0,4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l,c in zip(lambda_,colours):\n plt.plot( a, expo.pdf( a, scale=1./l), lw=3, \n color=c, label = \"$\\lambda = %.1f$\"%l)\n plt.fill_between( a, expo.pdf( a, scale=1./l), color=c, alpha = .33)\n \nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n###But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We only see $Z$, and must go backwards to try and determine $\\lambda$. The problem is so difficult because there is not a one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is better! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ is. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first: after all, $\\lambda$ is fixed, it is not (necessarily) random! How can we assign probabilities to a non-random event. Ah, we have fallen for the frequentist interpretation. Recall, under our Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, concerning text-message rates:\n\n> You are given a series of text-message counts from a user of your system. The data, plotted over time, appears in the graph below. You are curious if the user's text-messaging habits changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```\nfigsize( 12.5, 3.5 )\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar( np.arange( n_count_data ), count_data, color =\"#348ABD\" )\nplt.xlabel( \"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim( 0, n_count_data );\n```\n\nBefore we begin, with respect to the plot above, would you say there was a change in behaviour\nduring the time period? \n\nHow can we start to model this? Well, as I conveniently already introduced, a Poisson random variable would be a very appropriate model for this *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure about what the $\\lambda$ parameter is though. Looking at the chart above, it appears that the rate might become higher at some later date, which is equivalently saying the parameter $\\lambda$ increases at some later date (recall a higher $\\lambda$ means more probability on larger outcomes, that is, higher probability of many texts.).\n\nHow can we mathematically represent this? We can think, that at some later date (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we create two $\\lambda$ parameters, one for behaviour before the $\\tau$, and one for behaviour after. In literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\n If, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, the $\\lambda$'s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda_i, \\; i=1,2,$ can be any positive number. The *exponential* random variable has a density function for any positive number. This would be a good choice to model $\\lambda_i$. But, we need a parameter for this exponential distribution: call it $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter*, or a *parent-variable*, literally a parameter that influences other parameters. The influence is not too strong, so we can choose $\\alpha$ liberally. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data, since we're modeling $\\\\lambda$ using an Exponential distribution we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAlternatively, and something I encourage the reader to try, is to have two priors: one for each $\\lambda_i$; creating two exponential distributions with different $\\alpha$ values reflects a prior belief that the rate changed after some period.\n\nWhat about $\\tau$? Well, due to the randomness, it is too difficult to pick out when $\\tau$ might have occurred. Instead, we can assign an *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it would be an ugly, complicated, mess involving symbols only a mathematician would love. And things would only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution. We next turn to PyMC, a Python library for performing Bayesian analysis, that is agnostic to the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC\n-----\n\nPyMC is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that documentation can be lacking in areas, especially the bridge between beginner to hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC is so cool.\n\nWe will model the above problem using the PyMC library. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random. The title is given because we create probability models using programming variables as the model's components, that is, model components are first-class primitives in this framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nDue to its poorly understood title, I'll refrain from using the name *probabilistic programming*. Instead, I'll simply use *programming*, as that is what it really is. \n\nThe PyMC code is easy to follow along: the only novel thing should be the syntax, and I will interrupt the code to explain sections. Simply remember we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables:\n\n\n```\nimport pymc as mc\n\nn = count_data.shape[0]\n\nalpha = 1.0/count_data.mean() #recall count_data is \n #the variable that holds our txt counts\n\nlambda_1 = mc.Exponential( \"lambda_1\", alpha )\nlambda_2 = mc.Exponential( \"lambda_2\", alpha )\n\ntau = mc.DiscreteUniform( \"tau\", lower = 0, upper = n )\n```\n\nIn the above code, we create the PyMC variables corresponding to $\\lambda_1, \\; \\lambda_2$. We assign them to PyMC's *stochastic variables*, called stochastic variables because they are treated by the backend as random number generators. We can test this by calling their built-in `random()` method.\n\n\n```\nprint \"Random output:\", tau.random(),tau.random(), tau.random()\n```\n\n Random output: 13 12 54\n\n\n\n```\n@mc.deterministic\ndef lambda_( tau = tau, lambda_1 = lambda_1, lambda_2 = lambda_2 ):\n out = np.zeros( n ) \n out[:tau] = lambda_1 #lambda before tau is lambda1\n out[tau:] = lambda_2 #lambda after tau is lambda2\n return out\n```\n\nThis code is creating a new function `lambda_`, but really we think of it as a random variable: the random variable $\\lambda$ from above. Note that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet. The `@mc.deterministic` is a decorator to tell PyMC that this is a deterministic function, i.e., if the arguments were deterministic (which they are not), the output would be deterministic as well. \n\n\n```\nobservation = mc.Poisson( \"obs\", lambda_, value = count_data, observed = True)\n\nmodel = mc.Model( [observation, lambda_1, lambda_2, tau] )\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `value` keyword. We also set `observed = True` to tell PyMC that this should stay fixed in our analysis. Finally, PyMC wants us to collect all the variables of interest and create a `Model` instance out of them. This makes our life easier when we try to retrieve the results.\n\nThe below code will be explained in the Chapter 3, but this is where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Monte Carlo Markov Chains* (which I delay explaining until Chapter 3). It returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distribution looks like. Below, we collect the samples (called *traces* in MCMC literature) in histograms.\n\n\n```\n### Mysterious code to be explained in Chapter 3.\nmcmc = mc.MCMC(model)\nmcmc.sample( 35000, 5000, 1 )\n```\n\n [****************100%******************] 35000 of 35000 complete\n\n\n\n```\nlambda_1_samples = mcmc.trace( 'lambda_1' )[:]\nlambda_2_samples = mcmc.trace( 'lambda_2' )[:]\ntau_samples = mcmc.trace( 'tau' )[:]\n```\n\n\n```\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist( lambda_1_samples, histtype='stepfilled', bins = 30, alpha = 0.85, \n label = \"posterior of $\\lambda_1$\", color = \"#A60628\",normed = True )\nplt.legend(loc = \"upper left\")\nplt.title(r\"Posterior distributions of the variables $\\lambda_1,\\;\\lambda_2,\\;\\tau$\")\nplt.xlim([15,30])\nplt.xlabel(\"$\\lambda_2$ value\")\nplt.ylabel(\"probability\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\n\nplt.hist( lambda_2_samples,histtype='stepfilled', bins = 30, alpha = 0.85, \n label = \"posterior of $\\lambda_2$\",color=\"#7A68A6\", normed = True )\nplt.legend(loc = \"upper left\")\nplt.xlim([15,30])\nplt.xlabel(\"$\\lambda_2$ value\")\nplt.ylabel(\"probability\")\n\nplt.subplot(313)\n\n\nw = 1.0/ tau_samples.shape[0] * np.ones_like( tau_samples )\nplt.hist( tau_samples, bins = n_count_data, alpha = 1, \n label = r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth =1. )\n\nplt.legend(loc = \"upper left\");\nplt.ylim([0,.75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(\"days\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that the Bayesian methodology returns a *distribution*, hence we now have distributions to describe the unknown $\\lambda$'s and $\\tau$. What have we gained? Immediately we can see the uncertainty in our estimates: the more variance in the distribution, the less certain our posterior belief should be. We can also say what a plausible value for the parameters might be: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. What other observations can you make? Look at the data again, do these seem reasonable? The distributions of the two $\\\\lambda$s are positioned very differently, indicating that it's likely there was a change in the user's text-message behaviour.\n\nAlso notice that the posterior distributions for the $\\lambda$'s do not look like any exponential distributions, though we originally started modelling with exponential random variables. They are really not anything we recognize. But this is OK. This is one of the benefits of taking a computational point-of-view. If we had instead done this mathematically, we would have been stuck with a very analytically intractable (and messy) distribution. Via computations, we are agnostic to the tractability.\n\nOur analysis also returned a distribution for what $\\tau$ might be. Its posterior distribution looks a little different from the other two because it is a discrete random variable, hence it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance the users behaviour changed. Had no change occurred, or the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many values are likely candidates for $\\tau$. On the contrary, it is very peaked. \n\n###Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say we can perform amazingly useful things. For now, let's end this chapter with one more example. We'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le70$? Recall that the expected value of a Poisson is equal to its parameter $\\lambda$, then the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, we are calculating the following: Let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change hadn't occurred yet), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n\n\n\n___________________\n\n\n```\nfigsize( 12.5, 4)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\" (in the lambda1 \"regime\")\n # or \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed, \n # and therefore lambda (the poisson parameter) is the expected value of \"message count\"\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum() \n + lambda_2_samples[~ix].sum() ) /N\n\n \nplt.plot( range( n_count_data), expected_texts_per_day, lw =4, color = \"#E24A33\" )\nplt.xlim( 0, n_count_data )\nplt.xlabel( \"Day\" )\nplt.ylabel( \"Expected # text-messages\" )\nplt.title( \"Expected number of text-messages received\")\n#plt.ylim( 0, 35 )\nplt.bar( np.arange( len(count_data) ), count_data, color =\"#348ABD\", alpha = 0.5,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and the change was sudden rather then gradual (demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-2-text subscription, or a new relationship. (The 45th day corresponds to Christmas, and I moved away to Toronto the next month leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```\n#type your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```\n#type your code here.\n```\n\n3\\. Looking at the posterior distribution graph of $\\tau$, why do you think there is a small number of posterior $\\tau$ samples near 0? `hint:` Look at the data again.\n\n4\\. What is the mean of $\\lambda_1$ **given** we know $\\tau$ is less than 45. That is, suppose we have new information as we know for certain that the change in behaviour occurred before day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC part, just consider all instances where `tau_samples<45`. )\n\n\n```\n#type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. .\n\n\n```\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```\n\n```\n", "meta": {"hexsha": "b3ccb581fa3dab3ec95bb576ebeece7674001483", "size": 408118, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Chapter1_Introduction.ipynb", "max_stars_repo_name": "aespinoza/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "38751435529deea0a5637a1aff86b416317c7ac9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-12-28T04:08:27.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-28T04:08:27.000Z", "max_issues_repo_path": "Chapter1_Introduction/Chapter1_Introduction.ipynb", "max_issues_repo_name": "aespinoza/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "38751435529deea0a5637a1aff86b416317c7ac9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Chapter1_Introduction.ipynb", "max_forks_repo_name": "aespinoza/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "38751435529deea0a5637a1aff86b416317c7ac9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 390.1701720841, "max_line_length": 113544, "alphanum_fraction": 0.9033490314, "converted": true, "num_tokens": 10903, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3311197264277872, "lm_q2_score": 0.4416730056646256, "lm_q1q2_score": 0.14624664480620933}}
{"text": "Probability Theory Calculus \n \n \n\n- Let $p(A|I)$ indicate the belief in event $A$, given that $I$ is true. \n\n- The following product and sum rules are also known as the **axioms of probability theory**, but as discussed above, under some mild assumptions, they can be derived as the unique rules for *rational reasoning under uncertainty* ([Cox theorem, 1946](https://en.wikipedia.org/wiki/Cox%27s_theorem), and [Caticha, 2012](https://github.com/bertdv/BMLIP/blob/master/lessons/notebooks/files/Caticha-2012-Entropic-Inference-and-the-Foundations-of-Physics.pdf), pp.7-26).\n\n- **Sum rule**. The disjunction for two events $A$ and $B$ given background $I$ is given by\n$$ \\boxed{p(A+B|I) = p(A|I) + p(B|I) - p(A,B|I)}$$\n \n\n- **Product rule**. The conjuction of two events $A$ and $B$ with given background $I$ is given by \n$$ \\boxed{p(A,B|I) = p(A|B,I)\\,p(B|I)}$$\n \n \n\n- **All legitimate probabilistic relations can be derived from the sum and product rules!**\n\n### Independent and Mutually Exclusive Events\n\n- Two events $A$ and $B$ are said to be **independent** if the probability of one is not altered by information about the truth of the other, i.e., $p(A|B) = p(A)$\n - $\\Rightarrow$ If $A$ and $B$ are independent, given $I$, then the product rule simplifies to $$p(A,B|I) = p(A|I) p(B|I)$$\n\n- Two events $A_1$ and $A_2$ are said to be **mutually exclusive** if they cannot be true simultanously, i.e., if $p(A_1,A_2)=0$.\n - $\\Rightarrow$ For mutually exclusive events, the sum rule simplifies to\n $$p(A_1+A_2) = p(A_1) + p(A_2)$$\n \n\n- A set of events $A_1, A_2, \\ldots, A_N$ is said to be **collectively exhaustive** if one of the statements is necessarily true, i.e., $A_1+A_2+\\cdots +A_N=\\mathrm{TRUE}$, or equivalently \n$$p(A_1+A_2+\\cdots +A_N)=1$$\n\n\n- Note that, if $A_1, A_2, \\ldots, A_n$ are both **mutually exclusive** and **collectively exhausitive** (MECE) events, then\n $$\\sum_{n=1}^N p(A_n) = p(A_1 + \\ldots + A_N) = 1$$\n - More generally, if $\\{A_n\\}$ are MECE events, then $\\sum_{n=1}^N p(A_n,B) = p(B)$\n\n### The Sum Rule and Marginalization\n\n- We mentioned that every inference problem in PT can be evaluated through the sum and product rules. Next, we present two useful corollaries: (1) _Marginalization_ and (2) _Bayes rule_ \n\n- If $X \\in \\mathcal{X}$ and $Y \\in \\mathcal{Y}$ are random variables over finite domains, than it follows from the above considerations about MECE events that \n$$\n\\sum_{Y\\in \\mathcal{Y}} p(X,Y) = p(X) \\,.\n$$\n\n- Summing $Y$ out of a joint distribution $p(X,Y)$ is called **marginalization** and the result $p(X)$ is sometimes referred to as the **marginal probability**. \n\n- Note that this is just a **generalized sum rule**. In fact, Bishop (p.14) (and some other authors as well) calls this the sum rule.\n\n\n- Of course, in the continuous domain, the (generalized) sum rule becomes\n$$p(X)=\\int p(X,Y) \\,\\mathrm{d}Y$$\n\n### The Product Rule and Bayes Rule \n\n- Consider two variables $D$ and $\\theta$; it follows from symmetry arguments that \n$$p(D,\\theta)=p(D|\\theta)p(\\theta)=p(\\theta|D)p(D)$$ \nand hence that\n$$ p(\\theta|D) = \\frac{p(D|\\theta) }{p(D)}p(\\theta)\\,.$$ \n\n- This formula is called **Bayes rule** (or Bayes theorem). While Bayes rule is always true, a particularly useful application occurs when $D$ refers to an observed data set and $\\theta$ is set of model parameters. In that case,\n\n - the **prior** probability $p(\\theta)$ represents our **state-of-knowledge** about proper values for $\\theta$, before seeing the data $D$.\n - the **posterior** probability $p(\\theta|D)$ represents our state-of-knowledge about $\\theta$ after we have seen the data.\n\n$\\Rightarrow$ Bayes rule tells us how to update our knowledge about model parameters when facing new data. Hence, \n\n\n\nBayes rule is the fundamental rule for learning from data!\n
\n \n\n### Bayes Rule Nomenclature\n- Some nomenclature associated with Bayes rule:\n$$\n\\underbrace{p(\\theta | D)}_{\\text{posterior}} = \\frac{\\overbrace{p(D|\\theta)}^{\\text{likelihood}} \\times \\overbrace{p(\\theta)}^{\\text{prior}}}{\\underbrace{p(D)}_{\\text{evidence}}}\n$$\n\n- Note that the evidence (a.k.a. _marginal likelihood_ ) can be computed from the numerator through marginalization since\n$$ p(D) = \\int p(D,\\theta) \\,\\mathrm{d}\\theta = \\int p(D|\\theta)\\,p(\\theta) \\,\\mathrm{d}\\theta$$\n\n- Hence, having access to likelihood and prior is in principle sufficient to compute both the evidence and the posterior. To emphasize that point, Bayes rule is sometimes written as a transformation:\n\n$$ \\underbrace{\\underbrace{p(\\theta|D)}_{\\text{posterior}}\\cdot \\underbrace{p(D)}_{\\text{evidence}}}_{\\text{this is what we want to compute}} = \\underbrace{\\underbrace{p(D|\\theta)}_{\\text{likelihood}}\\cdot \\underbrace{p(\\theta)}_{\\text{prior}}}_{\\text{this is available}}$$ \n\n\n- For a given data set $D$, the posterior probabilities of the parameters scale relatively against each other as\n\n$$\np(\\theta|D) \\propto p(D|\\theta) p(\\theta)\n$$\n\n- $\\Rightarrow$ All that we can learn from the observed data is contained in the likelihood function $p(D|\\theta)$. This is called the **likelihood principle**.\n\n### The Likelihood Function vs the Sampling Distribution\n\n- Consider a distribution $p(D|\\theta)$, where $D$ relates to variables that are observed (i.e., a \"data set\") and $\\theta$ are model parameters.\n\n- In general, $p(D|\\theta)$ is just a function of the two variables $D$ and $\\theta$. We distinguish two interpretations of this function, depending on which variable is observed (or given by other means). \n\n- The **sampling distribution** (a.k.a. the **data-generating** distribution) $$p(D|\\theta=\\theta_0)$$ (which is a function of $D$ only) describes a probability distribution for data $D$, assuming that it is generated by the given model with parameters fixed at $\\theta = \\theta_0$.\n\n- In a machine learning context, often the data is observed, and $\\theta$ is the free variable. In that case, for given observations $D=D_0$, the **likelihood function** (which is a function only of the model parameters $\\theta$) is defined as $$\\mathrm{L}(\\theta) \\triangleq p(D=D_0|\\theta)$$\n\n- Note that $\\mathrm{L}(\\theta)$ is not a probability distribution for $\\theta$ since in general $\\sum_\\theta \\mathrm{L}(\\theta) \\neq 1$.\n\n### Code Example: Sampling Distribution and Likelihood Function for the Coin Toss\n\nConsider the following simple model for the outcome (head or tail) $y \\in \\{0,1\\}$ of a biased coin toss with parameter $\\theta \\in [0,1]$:\n\n$$\\begin{align*}\np(y|\\theta) &\\triangleq \\theta^y (1-\\theta)^{1-y}\\\\\n\\end{align*}$$\n\nWe can plot both the sampling distribution $p(y|\\theta=0.8)$ and the likelihood function $L(\\theta) = p(y=0|\\theta)$.\n\n\n```julia\nusing Pkg; Pkg.activate(\"probprog/workspace\");Pkg.instantiate();\nIJulia.clear_output();\n```\n\n\n```julia\nusing PyPlot\n#using Plots\np(y,θ) = θ.^y .* (1 .- θ).^(1 .- y)\nf = figure()\n\nθ = 0.5 # Set parameter\n# Plot the sampling distribution\nsubplot(221); stem([0,1], p([0,1],θ)); \ntitle(\"Sampling distribution\");\nxlim([-0.5,1.5]); ylim([0,1]); xlabel(\"y\"); ylabel(\"p(y|θ=$(θ))\");\n\nsubplot(222);\n_θ = 0:0.01:1\ny = 1.0 # Plot p(y=1 | θ)\nplot(_θ,p(y,_θ))\ntitle(\"Likelihood function\"); \nxlabel(\"θ\"); \nylabel(\"L(θ) = p(y=$y)|θ)\");\n\n\n```\n\nThe (discrete) sampling distribution is a valid probability distribution. \nHowever, the likelihood function $L(\\theta)$ clearly isn't, since $\\int_0^1 L(\\theta) \\mathrm{d}\\theta \\neq 1$. \n\n\n### Probabilistic Inference\n\n- **Probabilistic inference** refers to computing\n$$\np(\\,\\text{whatever-we-want-to-know}\\, | \\,\\text{whatever-we-already-know}\\,)\n$$\n - For example: \n $$\\begin{align*}\n p(\\,\\text{Mr.S.-killed-Mrs.S.} \\;&|\\; \\text{he-has-her-blood-on-his-shirt}\\,) \\\\\n p(\\,\\text{transmitted-codeword} \\;&|\\;\\text{received-codeword}\\,) \n \\end{align*}$$\n\n- This can be accomplished by repeated application of sum and product rules.\n\n- In particular, consider a joint distribution $p(X,Y,Z)$. Assume we are interested in $p(X|Z)$:\n$$\\begin{align*}\np(X|Z) \\stackrel{p}{=} \\frac{p(X,Z)}{p(Z)} \\stackrel{s}{=} \\frac{\\sum_Y p(X,Y,Z)}{\\sum_{X,Y} p(X,Y,Z)} \\,,\n\\end{align*}$$\nwhere the 's' and 'p' above the equality sign indicate whether the sum or product rule was used. \n\n- In the rest of this course, we'll encounter many long probabilistic derivations. For each manipulation, you should be able to associate an 's' (for sum rule), a 'p' (for product or Bayes rule) or an 'm' (for a simplifying model assumption) above any equality sign.\n\n### Working out the example problem: Disease Diagnosis\n\n- **Problem**: Given a disease $D$ with prevalence of $1\\%$ and a test procedure $T$ with sensitivity ('true positive' rate) of $95\\%$ and specificity ('true negative' rate) of $85\\%$, what is the chance that somebody who tests positive actually has the disease?\n\n- **Solution**: The given data are $p(D=1)=0.01$, $p(T=1|D=1)=0.95$ and $p(T=0|D=0)=0.85$. Then according to Bayes rule,\n\n$$\\begin{align*}\np( D=1 &| T=1) \\\\\n&\\stackrel{p}{=} \\frac{p(T=1|D=1)p(D=1)}{p(T=1)} \\\\\n&\\stackrel{s}{=} \\frac{p(T=1|D=1)p(D=1)}{p(T=1|D=1)p(D=1)+p(T=1|D=0)p(D=0)} \\\\\n&= \\frac{0.95\\times0.01}{0.95\\times0.01 + 0.15\\times0.99} = 0.0601\n\\end{align*}$$\n\n### Inference Exercise: Bag Counter\n\n- **Problem**: A bag contains one ball, known to be either white or black. A white ball is put in, the bag is shaken,\n and a ball is drawn out, which proves to be white. What is now the\n chance of drawing a white ball?\n \n\n- **Solution**: Again, use Bayes and marginalization to arrive at $p(\\text{white}|\\text{data})=2/3$, see the [Exercises](https://nbviewer.org/github/bertdv/BMLIP/blob/master/lessons/exercises/Exercises-Probability-Theory-Review.ipynb) notebook.\n\n- $\\Rightarrow$ Note that probabilities describe **a person's state of knowledge** rather than a 'property of nature'.\n\n### Inference Exercise: Causality?\n\n- **Problem**: A dark bag contains five red balls and seven green ones. (a) What is the probability of drawing a red ball on the first draw? Balls are not returned to the bag after each draw. (b) If you know that on the second draw the ball was a green one, what is now the probability of drawing a red ball on the first draw?\n\n- **Solution**: (a) $5/12$. (b) $5/11$, see the [Exercises](https://nbviewer.org/github/bertdv/BMLIP/blob/master/lessons/exercises/Exercises-Probability-Theory-Review.ipynb) notebook.\n\n- $\\Rightarrow$ Again, we conclude that conditional probabilities reflect **implications for a state of knowledge** rather than temporal causality.\n\n### Moments of the PDF\n\n- Consider a distribution $p(x)$. The **expected value** or **mean** is defined as \n$$\\mu_x = \\mathbb{E}[x] \\triangleq \\int x \\,p(x) \\,\\mathrm{d}{x}$$ \n\n- The **variance** of $x$ is defined as \n$$\\Sigma_x \\triangleq \\mathbb{E} \\left[(x-\\mu_x)(x-\\mu_x)^T \\right]$$ \n\n- The **covariance** matrix between _vectors_ $x$ and $y$ is defined as\n$$\\begin{align*}\n \\Sigma_{xy} &\\triangleq \\mathbb{E}\\left[ (x-\\mu_x) (y-\\mu_y)^T \\right]\\\\\n &= \\mathbb{E}\\left[ (x-\\mu_x) (y^T-\\mu_y^T) \\right]\\\\\n &= \\mathbb{E}[x y^T] - \\mu_x \\mu_y^T\n\\end{align*}$$\n - Clearly, if $x$ and $y$ are independent, then $\\Sigma_{xy} = 0$, since $\\mathbb{E}[x y^T] = \\mathbb{E}[x] \\mathbb{E}[y^T] = \\mu_x \\mu_y^T$.\n\n\n\n### Linear Transformations \n\n- Consider an arbitrary distribution $p(X)$ with mean $\\mu_x$ and variance $\\Sigma_x$ and the linear transformation $$Z = A X + b \\,.$$ \n\n- No matter the specification of $p(X)$, we can derive that (see [Exercises](https://nbviewer.org/github/bertdv/BMLIP/blob/master/lessons/exercises/Exercises-Probability-Theory-Review.ipynb) notebook)\n$$\\begin{align}\n\\mu_z &= A\\mu_x + b \\tag{SRG-3a}\\\\\n\\Sigma_z &= A\\,\\Sigma_x\\,A^T \\tag{SRG-3b}\n\\end{align}$$\n - (The tag (SRG-3a) refers to the corresponding eqn number in Sam Roweis [Gaussian identities](https://github.com/bertdv/BMLIP/blob/master/lessons/notebooks/files/Roweis-1999-gaussian-identities.pdf) notes.)\n\n\n\n\n### PDF for the Sum of Two Variables\n\n\n- Given eqs SRG-3a and SRG-3b (previous cell), you should now be able to derive the following: for any distribution of variable $X$ and $Y$ and sum $Z = X+Y$ (proof by [Exercise](https://nbviewer.org/github/bertdv/BMLIP/blob/master/lessons/exercises/Exercises-Probability-Theory-Review.ipynb))\n\n$$\\begin{align*}\n \\mu_z &= \\mu_x + \\mu_y \\\\\n \\Sigma_z &= \\Sigma_x + \\Sigma_y + 2\\Sigma_{xy} \n\\end{align*}$$\n\n- Clearly, it follows that if $X$ and $Y$ are **independent**, then\n\n$$\\Sigma_z = \\Sigma_x + \\Sigma_y $$\n\n- More generally, given two **independent** variables\n$X$ and $Y$, with PDF's $p_x(x)$ and $p_y(y)$. The PDF $p_z(z)$for $Z=X+Y$ is given by the **convolution**\n\n$$\np_z (z) = \\int_{ - \\infty }^\\infty {p_x (x)p_y (z - x)\\,\\mathrm{d}{x}}\n$$ \n\n- **Proof**: Let $p_z(z)$ be the probability that $Z$ has value $z$. This occurs if $X$ has some value $x$ and at the same time $Y=z-x$, with joint probability $p_x(x)p_y(z-x)$. Since $x$ can be any value, we sum over all possible values for $x$ to get\n$\np_z (z) = \\int_{ - \\infty }^\\infty {p_x (x)p_y (z - x)\\,\\mathrm{d}{x}}\n$ \n \n - Note that $p_z(z) \\neq p_x(x) + p_y(y)\\,$ !!\n \n\n- [https://en.wikipedia.org/wiki/List_of_convolutions_of_probability_distributions](https://en.wikipedia.org/wiki/List_of_convolutions_of_probability_distributions) shows how these convolutions work out for a few common probability distributions. \n\n- In linear stochastic systems theory, the Fourier Transform of a PDF (i.e., the characteristic function) plays an important computational role. Why?\n\n### Code Example: Sum of Two Gaussian Distributed Variables\n\n- Consider the PDF of the sum of two independent Gaussian distributed $X$ and $Y$:\n\n$$\\begin{align*}\np_X(x) &= \\mathcal{N}(\\,x\\,|\\,\\mu_X,\\sigma_X^2\\,) \\\\ \np_Y(y) &= \\mathcal{N}(\\,y\\,|\\,\\mu_Y,\\sigma_Y^2\\,) \n\\end{align*}$$\n\n- Let $Z = X + Y$. Performing the convolution (nice exercise) yields a Gaussian PDF for $Z$: \n\n$$\np_Z(z) = \\mathcal{N}(\\,z\\,|\\,\\mu_X+\\mu_Y,\\sigma_X^2+\\sigma_Y^2\\,).\n$$\n\n\n```julia\nusing PyPlot, Distributions\nμx = 2.\nσx = 1.\nμy = 2.\nσy = 0.5\nμz = μx+μy; σz = sqrt(σx^2 + σy^2)\nx = Normal(μx, σx)\ny = Normal(μy, σy)\nz = Normal(μz, σz)\nrange_min = minimum([μx-2*σx, μy-2*σy, μz-2*σz])\nrange_max = maximum([μx+2*σx, μy+2*σy, μz+2*σz])\nrange_grid = range(range_min, stop=range_max, length=100)\nplot(range_grid, pdf.(x,range_grid), \"k-\")\nplot(range_grid, pdf.(y,range_grid), \"b-\")\nplot(range_grid, pdf.(z,range_grid), \"r-\")\nlegend([L\"p_X\", L\"p_Y\", L\"p_Z\"])\ngrid()\n```\n\n### PDF for the Product of Two Variables\n\n- For two continuous random **independent** variables\n$X$ and $Y$, with PDF's $p_x(x)$ and $p_y(y)$, the PDF of \n$Z = X Y $ is given by \n$$\np_z(z) = \\int_{-\\infty}^{\\infty} p_x(x) \\,p_y(z/x)\\, \\frac{1}{|x|}\\,\\mathrm{d}x\n$$\n\n- For proof, see [https://en.wikipedia.org/wiki/Product_distribution](https://en.wikipedia.org/wiki/Product_distribution)\n\n- Generally, this integral does not lead to an analytical expression for $p_z(z)$. For example, [**the product of two independent variables that are both normally (Gaussian) distributed does not lead to a normal distribution**](https://nbviewer.jupyter.org/github/bertdv/BMLIP/blob/master/lessons/notebooks/The-Gaussian-Distribution.ipynb#product-of-gaussians).\n - Exception: the distribution of the product of two variables that both have [log-normal distributions](https://en.wikipedia.org/wiki/Log-normal_distribution) is again a lognormal distribution.\n - (If $X$ has a normal distribution, then $Y=\\exp(X)$ has a log-normal distribution.)\n\n### Variable Transformations\n\n- Suppose $x$ is a **discrete** random variable with probability **mass** function $P_x(x)$, and $y = h(x)$ is a one-to-one function with $x = g(y) = h^{-1}(y)$. Then\n\n$$\nP_y(y) = P_x(g(y))\\,.\n$$\n\n- **Proof**: $P_y(\\hat{y}) = P(y=\\hat{y}) = P(h(x)=\\hat{y}) = P(x=g(\\hat{y})) = P_x(g(\\hat{y})). \\,\\square$\n\n- If $x$ is defined on a **continuous** domain, and $p_x(x)$ is a probability **density** function, then probability mass is represented by the area under a (density) curve. Let $a=g(c)$ and $b=g(d)$. Then\n$$\\begin{align*}\nP(a ≤ x ≤ b) &= \\int_a^b p_x(x)\\mathrm{d}x \\\\\n &= \\int_{g(c)}^{g(d)} p_x(x)\\mathrm{d}x \\\\\n &= \\int_c^d p_x(g(y))\\mathrm{d}g(y) \\\\\n &= \\int_c^d \\underbrace{p_x(g(y)) g^\\prime(y)}_{p_y(y)}\\mathrm{d}y \\\\ \n &= P(c ≤ y ≤ d)\n\\end{align*}$$\n\n- Equating the two probability masses leads to identificaiton of the relation \n$$p_y(y) = p_x(g(y)) g^\\prime(y)\\,,$$ \nwhich is also known as the [Change-of-Variable theorem](https://en.wikipedia.org/wiki/Probability_density_function#Function_of_random_variables_and_change_of_variables_in_the_probability_density_function). \n\n- If the tranformation $y = h(x)$ is not invertible, then $x=g(y)$ does not exist. In that case, you can still work out the transformation by equating equivalent probability masses in the two domains. \n\n### Example: Transformation of a Gaussian Variable\n\n- Let $p_x(x) = \\mathcal{N}(x|\\mu,\\sigma^2)$ and $y = \\frac{x-\\mu}{\\sigma}$. \n\n- **Problem**: What is $p_y(y)$? \n\n- **Solution**: Note that $h(x)$ is invertible with $x = g(y) = \\sigma y + \\mu$. The change-of-variable formula leads to\n$$\\begin{align*}\np_y(y) &= p_x(g(y)) \\cdot g^\\prime(y) \\\\\n &= p_x(\\sigma y + \\mu) \\cdot \\sigma \\\\\n &= \\frac{1}{\\sigma\\sqrt(2 \\pi)} \\exp\\left( - \\frac{(\\sigma y + \\mu - \\mu)^2}{2\\sigma^2}\\right) \\cdot \\sigma \\\\\n &= \\frac{1}{\\sqrt(2 \\pi)} \\exp\\left( - \\frac{y^2 }{2}\\right)\\\\\n &= \\mathcal{N}(y|0,1) \n\\end{align*}$$\n\n### Summary\n\n- Probabilities should be interpretated as degrees of belief, i.e., a state-of-knowledge, rather than a property of nature.\n\n- We can do everything with only the **sum rule** and the **product rule**. In practice, **Bayes rule** and **marginalization** are often very useful for inference, i.e., for computing\n\n$$p(\\,\\text{what-we-want-to-know}\\,|\\,\\text{what-we-already-know}\\,)\\,.$$\n\n- Bayes rule $$ p(\\theta|D) = \\frac{p(D|\\theta)p(\\theta)} {p(D)} $$ is the fundamental rule for learning from data!\n\n- For a variable $X$ with distribution $p(X)$ with mean $\\mu_x$ and variance $\\Sigma_x$, the mean and variance of the **Linear Transformation** $Z = AX +b$ is given by \n$$\\begin{align}\n\\mu_z &= A\\mu_x + b \\tag{SRG-3a}\\\\\n\\Sigma_z &= A\\,\\Sigma_x\\,A^T \\tag{SRG-3b}\n\\end{align}$$\n\n- That's really about all you need to know about probability theory, but you need to _really_ know it, so do the [Exercises](https://nbviewer.org/github/bertdv/BMLIP/blob/master/lessons/exercises/Exercises-Probability-Theory-Review.ipynb).\n\n\n```julia\nopen(\"../../styles/aipstyle.html\") do f\n display(\"text/html\", read(f,String))\nend\n```\n\n\n\n\n\n:4: FutureWarning: In v4.0, pm.sample will return an `arviz.InferenceData` object instead of a `MultiTrace` by default. You can pass return_inferencedata=True or return_inferencedata=False to be safe and silence this warning.\n trace = pm.sample(10000, tune=5000,step=step)\n Multiprocess sampling (2 chains in 2 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n\n\n\n\n\n \n
\n 100.00% [30000/30000 00:08<00:00 Sampling 2 chains, 0 divergences]\n
\n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "fcb9172b50c12139637367daf6a49f5aa24c4395", "size": 317208, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "sparcs/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "2f74077ff95f1e526c6dbdbe43d05bc704383119", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "sparcs/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "2f74077ff95f1e526c6dbdbe43d05bc704383119", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "sparcs/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "2f74077ff95f1e526c6dbdbe43d05bc704383119", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 292.6273062731, "max_line_length": 88724, "alphanum_fraction": 0.9035963784, "converted": true, "num_tokens": 11465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.30074557894124154, "lm_q1q2_score": 0.14332922307076013}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n :4: FutureWarning: In v4.0, pm.sample will return an `arviz.InferenceData` object instead of a `MultiTrace` by default. You can pass return_inferencedata=True or return_inferencedata=False to be safe and silence this warning.\n trace = pm.sample(10000, tune=5000,step=step)\n Multiprocess sampling (4 chains in 4 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n\n\n\n\n\n \n
\n 100.00% [60000/60000 00:06<00:00 Sampling 4 chains, 0 divergences]\n
\n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "afdebced708b95b2ad2fa7a7d41d91092c8d4c32", "size": 304720, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "kanishkd4/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "6a7976737905cd92abef560eea94aa8944b0adc5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "kanishkd4/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "6a7976737905cd92abef560eea94aa8944b0adc5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "kanishkd4/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "6a7976737905cd92abef560eea94aa8944b0adc5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 275.0180505415, "max_line_length": 82984, "alphanum_fraction": 0.89841822, "converted": true, "num_tokens": 11462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295350395727, "lm_q2_score": 0.32082130731838393, "lm_q1q2_score": 0.14293536788034747}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n 100%|██████████████████████████████████████████████████████████████████████████| 15000/15000 [00:06<00:00, 2447.84it/s]\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n#type your code here.\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n#type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a350135d91e728d25cfc49996061c04bacab56c0", "size": 302889, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "20_Bayesian_Methods_for_Hackers/Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "MichaelRW/Kalman_and_Bayesian_Filtering", "max_stars_repo_head_hexsha": "2e9394c7942872b155228ed7b21798527961282b", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "20_Bayesian_Methods_for_Hackers/Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "MichaelRW/Kalman_and_Bayesian_Filtering", "max_issues_repo_head_hexsha": "2e9394c7942872b155228ed7b21798527961282b", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "20_Bayesian_Methods_for_Hackers/Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "MichaelRW/Kalman_and_Bayesian_Filtering", "max_forks_repo_head_hexsha": "2e9394c7942872b155228ed7b21798527961282b", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 282.5457089552, "max_line_length": 90672, "alphanum_fraction": 0.8914354764, "converted": true, "num_tokens": 11393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262437, "lm_q2_score": 0.30404167496654744, "lm_q1q2_score": 0.1425318873280605}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\nOriginal content created by Cam Davidson-Pilon\n\nPorted to [Pyro](http://pyro.ai/) by Carlos Souza (souza@gatech.edu), with the help from [Pyro community](https://forum.pyro.ai/).\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n%matplotlib inline\n\nimport torch\nimport pyro\nimport pyro.distributions as dist\nfrom pyro.infer import MCMC, NUTS, HMC\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\n```\n\n\n```python\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\nx = np.linspace(0, 1, 100)\ndata = pyro.sample('coin_toss', pyro.distributions.Bernoulli(0.5), [n_trials[-1]])\n```\n\n\n```python\nfigsize(11, 9)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n d = pyro.distributions.Beta(1 + heads, 1 + N - heads)\n y = torch.exp(d.log_prob(torch.tensor(x)))\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$?\n\n\n```python\nfigsize(12.5, 4)\np = torch.linspace(0, 1, 50)\nplt.plot(p, 2 * p / (1 + p), color=\"#348ABD\", lw=3)\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nlambda_ = [1.5, 4.25]\n\nd = dist.Poisson(torch.tensor(lambda_))\nx = torch.arange(16).float().view(-1, 1)\ny = torch.exp(d.log_prob(x))\n\ncolours = [\"#348ABD\", \"#A60628\"]\nplt.bar(x.flatten(), y[:, 0], color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(x.flatten(), y[:, 1], color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(x.flatten().numpy() + 0.4, x.flatten().numpy().astype(int))\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\nlambda_ = [0.5, 1]\nd = dist.Exponential(torch.tensor(lambda_))\n\nx = torch.linspace(0, 4, 100).view(-1, 1)\ny = torch.exp(d.log_prob(x))\n```\n\n\n```python\nfor i, c in enumerate(colours):\n plt.plot(x.flatten(), y[:, i], lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % lambda_[i])\n plt.fill_between(x.flatten(), y[:, i], color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = torch.from_numpy(np.loadtxt(\"data/txtdata.csv\"))\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to [Pyro](https://pyro.ai/), a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\n## Introducing our first hammer: Pyro\n\nPyro is a Python library for programming Bayesian analysis. It is intended for data scientists, statisticians, machine learning practitioners, and scientists. Since it is built on the PyTorch stack, it brings the runtime benefits of PyTorch to Bayesian analysis. These include write-once run-many (ability to run your development model in production) and speedups via state-of-the-art hardware (GPUs and TPUs). \n\nSince Pyro is relatively new, the Pyro community is actively developing documentation, \nespecially docs and examples that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why TFP is so cool.\n\nWe will model the problem above using Pyro. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. \n\nB. Cronin [[4]](#scrollTo=nDdph0r1ABCn) has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n \nPyro code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\ndef model(data):\n alpha = 1.0 / data.mean()\n lambda_1 = pyro.sample(\"lambda_1\", dist.Exponential(alpha))\n lambda_2 = pyro.sample(\"lambda_2\", dist.Exponential(alpha))\n \n tau = pyro.sample(\"tau\", dist.Uniform(0, 1))\n lambda1_size = (tau * data.size(0) + 1).long()\n lambda2_size = data.size(0) - lambda1_size\n lambda_ = torch.cat([lambda_1.expand((lambda1_size,)),\n lambda_2.expand((lambda2_size,))])\n\n with pyro.plate(\"data\", data.size(0)):\n pyro.sample(\"obs\", dist.Poisson(lambda_), obs=data)\n```\n\n\n```python\nkernel = NUTS(model, jit_compile=True, ignore_jit_warnings=True, max_tree_depth=3)\nposterior = MCMC(kernel, num_samples=5000, warmup_steps=500)\nposterior.run(count_data);\n```\n\n Sample: 100%|██████████| 5500/5500 [00:43, 126.11it/s, step size=2.45e-01, acc. prob=0.802]\n\n\n\n```python\nhmc_samples = {k: v.detach().cpu().numpy() for k, v in posterior.get_samples().items()}\nlambda_1_samples = hmc_samples['lambda_1']\nlambda_2_samples = hmc_samples['lambda_2']\ntau_samples = (hmc_samples['tau'] * count_data.size(0) + 1).astype(int)\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n# Your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n# Your code here.\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n# Your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "23f48286202869a8db7b57f4fbcc546ea08f9eee", "size": 290138, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_Pyro.ipynb", "max_stars_repo_name": "thien/probabilistic", "max_stars_repo_head_hexsha": "2194af37805a183abbefa723921cea4d9dc8dd2a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_Pyro.ipynb", "max_issues_repo_name": "thien/probabilistic", "max_issues_repo_head_hexsha": "2194af37805a183abbefa723921cea4d9dc8dd2a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_Pyro.ipynb", "max_forks_repo_name": "thien/probabilistic", "max_forks_repo_head_hexsha": "2194af37805a183abbefa723921cea4d9dc8dd2a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 291.0110330993, "max_line_length": 87912, "alphanum_fraction": 0.9042455659, "converted": true, "num_tokens": 10136, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.3208213138121609, "lm_q1q2_score": 0.14169811395269116}}
{"text": "```python\nfrom IPython.core.display import HTML\nHTML(\"\"\"\n\n\"\"\")\n```\n\n\n\n\n\n\n\n\n\n\n# *Circuitos Elétricos I - Semana 11*\n\n### A integral de Laplace\n\nSeja $f(t)$ uma função definida no intervalo $0\\leq t \\leq \\infty$, com $t$ e $f(t)$ reais, então a função $F(s)$, definida pela integral de Laplace\n\n$$\\large\n\\begin{equation}\nF(s)=\\mathcal{L}\\{f(t)\\}=\\int_{0}^{\\infty} f(t) e^{-s t} dt,\\;\\; s \\in \\mathbb{C},\n\\end{equation}\n$$\n\né conhecida como a transformada de Laplace de $f(t)$.\n\nPara informações sobre como utilizar o Sympy para o cálculo da transformada de Laplace:\n\nhttps://dynamics-and-control.readthedocs.io/en/latest/1_Dynamics/3_Linear_systems/Laplace%20transforms.html\n\n\n```python\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sp\nfrom utils import round_expr, symdisp, symplot\n\nfrom sympy.polys.partfrac import apart\n\n# temp workaround\nimport warnings\nfrom matplotlib import MatplotlibDeprecationWarning\nwarnings.filterwarnings('ignore', category=MatplotlibDeprecationWarning)\n\nplt.rcParams['figure.figsize'] = 6, 4\nplt.rcParams['legend.fontsize'] = 13\nplt.rcParams['lines.linewidth'] = 2\nplt.rcParams['axes.grid'] = False\n```\n\n\n```python\n# transformada de Laplace\ndef L(f,t,s):\n return sp.laplace_transform(f, t, s, noconds=True)\n\n# transformada inversa de Laplace\ndef invL(F,s,t):\n return sp.re(sp.inverse_laplace_transform(F, s, t, noconds=True))\n\n# funções para auxílio na expansão em frações parciais\ndef adjustCoeff(expr): \n coeff = expr.as_numer_denom()\n c0 = sp.poly(coeff[1].cancel()).coeffs()[0]\n \n return (coeff[0].cancel()/c0)/(coeff[1].cancel()/c0)\n\ndef partFrac(expr, Ndigits):\n expr = expr.cancel()\n expr = apart(adjustCoeff(expr), s, full=True).doit()\n \n return sp.N(expr, Ndigits)\n\nsp.init_printing()\n```\n\n#### Definindo algumas variáveis simbólicas de interesse\n\n\n```python\nt, s = sp.symbols('t, s')\na = sp.symbols('a', real=True, positive=True)\nomega = sp.symbols('omega', real=True)\n```\n\n## Gere sua tabela de transformadas\n\n\n```python\nfunc = [1,\n t,\n sp.exp(-a*t),\n t*sp.exp(-a*t),\n t**2*sp.exp(-a*t),\n sp.sin(omega*t),\n sp.cos(omega*t),\n 1 - sp.exp(-a*t),\n sp.exp(-a*t)*sp.sin(omega*t),\n sp.exp(-a*t)*sp.cos(omega*t),\n ]\nfunc\n```\n\n\n```python\nFs = [L(f,t,s) for f in func]\nFs\n```\n\n### Problema 1\n\nNão existe nenhuma energia armazenada no circuito da figura a seguir no momento em que a fonte de corrente é ligada.\n\n\n\na. Determine $I_a(s)$ e $I_b(s)$.\\\nb. Determine $i_a(t)$ e $i_b(t)$.\\\nc. Determine $V_a(s)$, $V_b(s)$ e $V_c(s)$.\\\nd. Determine $v_a(t)$, $v_b(t)$ e $v_c(t)$.\n\n\n\na. Determinando $I_a(s)$ e $I_b(s)$:\n\n\n```python\nI2, I3, s = sp.symbols('I2, I3, s')\n\n# define os sistema de equações\neq1 = sp.Eq((4 + s)*I2 - 2*I3, 4) \neq2 = sp.Eq(-2*s*I2 + s*(4 + s)*I3, 8) \n\n# resolve o sistema\nsoluc = sp.solve([eq1, eq2],[I2, I3], dict=True)\nsoluc\n\nI2 = [sol[I2] for sol in soluc]\nI3 = [sol[I3] for sol in soluc]\n\nI1 = 4/s\nI2 = I2[0]\nI3 = I3[0]\n\nprint('Correntes de malha no domínio de Laplace: \\n')\nsymdisp('I_1(s) =', I1, 'As')\nsymdisp('I_2(s) =', I2, 'As')\nsymdisp('I_3(s) =', I3, 'As')\n```\n\n Correntes de malha no domínio de Laplace: \n \n\n\n\n$\\displaystyle I_1(s) =\\frac{4}{s}\\;As$\n\n\n\n$\\displaystyle I_2(s) =\\frac{4 s + 8}{s^{2} + 6 s}\\;As$\n\n\n\n$\\displaystyle I_3(s) =\\frac{16}{s^{2} + 6 s}\\;As$\n\n\n\n```python\n# Calculando Ia\nIa = I1-I2\nIa = Ia.simplify()\n\nsymdisp('I_a(s) =', Ia, 'As')\n```\n\n\n$\\displaystyle I_a(s) =\\frac{16}{s \\left(s + 6\\right)}\\;As$\n\n\n\n```python\n# Calculando Ib\nIb = I2\n\nsymdisp('I_b(s) =', Ib, 'As')\n```\n\n\n$\\displaystyle I_b(s) =\\frac{4 s + 8}{s^{2} + 6 s}\\;As$\n\n\nb. Determinando $i_a(t)$ e $i_b(t)$\n\n\n```python\nsymdisp('I_a(s) =', Ia.apart(), 'As')\n```\n\n\n$\\displaystyle I_a(s) =- \\frac{8}{3 \\left(s + 6\\right)} + \\frac{8}{3 s}\\;As$\n\n\n\n```python\nt = sp.symbols('t',real=True)\n\nia = invL(Ia.apart(),s,t)\n\nsymdisp('i_a(t) =', ia, 'A')\n```\n\n\n$\\displaystyle i_a(t) =\\frac{8 \\left(e^{6 t} - 1\\right) e^{- 6 t} \\theta\\left(t\\right)}{3}\\;A$\n\n\n\n```python\nsymdisp('I_b(s) =', Ib.apart(), 'As')\n```\n\n\n$\\displaystyle I_b(s) =\\frac{8}{3 \\left(s + 6\\right)} + \\frac{4}{3 s}\\;As$\n\n\n\n```python\nib = invL(Ib,s,t)\n\nsymdisp('i_b(t) =', ib, 'A')\n```\n\n\n$\\displaystyle i_b(t) =\\frac{4 \\left(e^{6 t} + 2\\right) e^{- 6 t} \\theta\\left(t\\right)}{3}\\;A$\n\n\nc. Determinando $V_a(s)$, $V_b(s)$ e $V_c(s)$.\n\n\n```python\nVa = (100/s)*I2\nVb = (100/s)*(I3-I2)\nVc = (100/s)*(I1-I3)\n\nsymdisp('V_a(s) =', Va.simplify(), 'Vs')\nsymdisp('V_b(s) =', Vb.simplify(), 'Vs')\nsymdisp('V_c(s) =', Vc.simplify(), 'Vs')\n```\n\n\n$\\displaystyle V_a(s) =\\frac{400 \\left(s + 2\\right)}{s^{2} \\left(s + 6\\right)}\\;Vs$\n\n\n\n$\\displaystyle V_b(s) =\\frac{400 \\left(2 - s\\right)}{s^{2} \\left(s + 6\\right)}\\;Vs$\n\n\n\n$\\displaystyle V_c(s) =\\frac{400 \\left(s + 2\\right)}{s^{2} \\left(s + 6\\right)}\\;Vs$\n\n\n\n```python\nsymdisp('V_a(s) =', Va.apart(), 'Vs')\n```\n\n\n$\\displaystyle V_a(s) =- \\frac{400}{9 \\left(s + 6\\right)} + \\frac{400}{9 s} + \\frac{400}{3 s^{2}}\\;Vs$\n\n\n\n```python\nsymdisp('V_b(s) =', Vb.apart(), 'Vs')\n```\n\n\n$\\displaystyle V_b(s) =\\frac{800}{9 \\left(s + 6\\right)} - \\frac{800}{9 s} + \\frac{400}{3 s^{2}}\\;Vs$\n\n\n\n```python\nsymdisp('V_c(s) =', Vc.apart(), 'Vs')\n```\n\n\n$\\displaystyle V_c(s) =- \\frac{400}{9 \\left(s + 6\\right)} + \\frac{400}{9 s} + \\frac{400}{3 s^{2}}\\;Vs$\n\n\nd. Determinando $v_a(t)$, $v_b(t)$ e $v_c(t)$.\n\n\n```python\nva = ((-400/9)*sp.exp(-6*t) + (400/9) + (400/3)*t)*sp.Heaviside(t)\n\nsymdisp('v_a(t) =', round_expr(va,2), 'V')\n```\n\n\n$\\displaystyle v_a(t) =\\left(133.33 t + 44.44 - 44.44 e^{- 6 t}\\right) \\theta\\left(t\\right)\\;V$\n\n\n\n```python\nvb = ((800/9)*sp.exp(-6*t) - (800/9) + (400/3)*t)*sp.Heaviside(t)\n\nsymdisp('v_b(t) =', round_expr(vb,2), 'V')\n```\n\n\n$\\displaystyle v_b(t) =\\left(133.33 t - 88.89 + 88.89 e^{- 6 t}\\right) \\theta\\left(t\\right)\\;V$\n\n\n\n```python\nvc = va\n\nsymdisp('v_c(t) =', round_expr(vc,2), 'V')\n```\n\n\n$\\displaystyle v_c(t) =\\left(133.33 t + 44.44 - 44.44 e^{- 6 t}\\right) \\theta\\left(t\\right)\\;V$\n\n\n\n```python\n# plota funções no domínio do tempo\nintervalo = np.arange(-4, 10, 0.1)\nsymplot(t, [va, vb, vc], intervalo, ['va(t)','vb(t)','vc(t)'])\n```\n\nPergunta: estas soluções fazem sentido para o circuito analisado?\n\n### Problema 2\n\nNão existe nenhuma energia armazenada no circuito da figura a seguir no momento em que a fonte de tensão é conectada.\n\n\n\na. Determine $V_0(s)$.\\\nb. Determine $v_0(t)$.\n\n\n\n\n```python\nIa, Ib, s = sp.symbols('Ia, Ib, s')\n\n# define o sistema de equações\neq1 = sp.Eq(10*Ia + (s + 250/s)*Ib, 35/s) \neq2 = sp.Eq(Ia - (1 + 0.4*s)*Ib, 0)\n\n# resolve o sistema\nsoluc = sp.solve([eq1, eq2],[Ia, Ib], dict=True)\nsoluc\n\nIa = [sol[Ia] for sol in soluc]\nIb = [sol[Ib] for sol in soluc]\n\nIa = Ia[0]\nIb = Ib[0]\n```\n\n\n```python\nsymdisp('I_a(s) =', Ia.simplify(), 'As')\n```\n\n\n$\\displaystyle I_a(s) =\\frac{14.0 s + 35.0}{5.0 s^{2} + 10.0 s + 250.0}\\;As$\n\n\n\n```python\nsymdisp('I_b(s) =', Ib.simplify(), 'As')\n```\n\n\n$\\displaystyle I_b(s) =\\frac{7.0}{s^{2} + 2.0 s + 50.0}\\;As$\n\n\n\n```python\nV0 = 35/s - 2*Ia\n\nsymdisp('V_0(s) =', V0.simplify(), 'Vs')\n```\n\n\n$\\displaystyle V_0(s) =\\frac{147.0 s^{2} + 280.0 s + 8750.0}{s \\left(5.0 s^{2} + 10.0 s + 250.0\\right)}\\;Vs$\n\n\n\n```python\nsymdisp('V_0(s) =', partFrac(V0, 2), 'Vs')\n```\n\n\n$\\displaystyle V_0(s) =\\frac{-2.8 - 0.59 i}{s + 1.0 + 7.0 i} + \\frac{-2.8 + 0.59 i}{s + 1.0 - 7.0 i} + \\frac{35.0}{s}\\;Vs$\n\n\n\n```python\nraizes = np.roots([1, 2, 50, 0])\nraizes\n```\n\n\n\n\n array([-1.+7.j, -1.-7.j, 0.+0.j])\n\n\n\n\n```python\nK = sp.symbols('K')\nσ, ω = sp.symbols('σ, ω', real=True)\n\nj = sp.I\n\nF = K/(s + σ + j*ω) + sp.conjugate(K)/(s + σ - j*ω)\n\nsymdisp('F(s) =', F)\n```\n\n\n$\\displaystyle F(s) =\\frac{K}{s + σ + i ω} + \\frac{\\overline{K}}{s + σ - i ω}\\; $\n\n\n\n```python\nsymdisp('f(t) =', invL(F,s,t))\n```\n\n\n$\\displaystyle f(t) =\\left(2 \\sin{\\left(t ω \\right)} \\operatorname{im}{\\left(K\\right)} + 2 \\cos{\\left(t ω \\right)} \\operatorname{re}{\\left(K\\right)}\\right) e^{- t σ} \\theta\\left(t\\right)\\; $\n\n\n\n```python\nv0 = (35 + sp.exp(-t)*(-5.6*sp.cos(7*t)-1.2*sp.sin(7*t)))*sp.Heaviside(t)\n\nsymdisp('v_0(t) =', v0)\n```\n\n\n$\\displaystyle v_0(t) =\\left(\\left(- 1.2 \\sin{\\left(7 t \\right)} - 5.6 \\cos{\\left(7 t \\right)}\\right) e^{- t} + 35\\right) \\theta\\left(t\\right)\\; $\n\n\n\n```python\n# plota funções no domínio do tempo\nintervalo = np.arange(-4, 10, 0.05)\nsymplot(t, v0, intervalo, 'v0(t)')\n```\n", "meta": {"hexsha": "bfc9ba7d28a1e0161ce53bf30e1dc8c9ac255a5a", "size": 71561, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Jupyter notebooks/.ipynb_checkpoints/Circuitos Eletricos I - Semana 11.2-checkpoint.ipynb", "max_stars_repo_name": "Jefferson-Lopes/ElectricCircuits", "max_stars_repo_head_hexsha": "bf2075dc0731cacece75f7b0b378c180630bdf85", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2021-05-19T18:36:53.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-18T16:30:17.000Z", "max_issues_repo_path": "Jupyter notebooks/.ipynb_checkpoints/Circuitos Eletricos I - Semana 11.2-checkpoint.ipynb", "max_issues_repo_name": "Jefferson-Lopes/ElectricCircuits", "max_issues_repo_head_hexsha": "bf2075dc0731cacece75f7b0b378c180630bdf85", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Jupyter notebooks/.ipynb_checkpoints/Circuitos Eletricos I - Semana 11.2-checkpoint.ipynb", "max_forks_repo_name": "Jefferson-Lopes/ElectricCircuits", "max_forks_repo_head_hexsha": "bf2075dc0731cacece75f7b0b378c180630bdf85", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2021-06-25T12:52:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-11T14:25:48.000Z", "avg_line_length": 68.8086538462, "max_line_length": 21724, "alphanum_fraction": 0.7872304747, "converted": true, "num_tokens": 3416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207956, "lm_q2_score": 0.28776782797747225, "lm_q1q2_score": 0.14163591077265467}}
{"text": "```python\nimport holoviews as hv\nhv.extension('bokeh')\nhv.opts.defaults(hv.opts.Curve(width=500), \n hv.opts.Points(width=500), \n hv.opts.Image(width=500, colorbar=True, cmap='Viridis'))\n```\n\n\n```python\nimport numpy as np\nimport scipy.linalg\n```\n\n# Estimador lineal óptimo\n\nUn **estimador** es un sistema diseñado para **extraer información** a partir de una **señal**\n\n- La señal contiene **información y ruido** \n- La señal es representada como una secuencia de **datos**\n\nTipos de estimador\n\n- **Filtro:** Estimo el valor actual de mi señal acentuando o eliminando una o más características\n- **Predictor:** Estimo el valor futuro de mi señal\n\nEn esta lección estudiaremos estimadores lineales y óptimos\n\n- Lineal: La cantidad estimada es una función lineal de la entrada\n- Óptimo: El estimador es la mejor solución posible de acuerdo a un criterio\n\nPara entender los fundamentos de los estimadores óptimos es necesario introducir el concepto de proceso aleatorio. Luego estudiaremos uno de los estimadores óptimos más importantes: El filtro de Wiener\n\n## Proceso aleatorio o proceso estocástico\n\nUn proceso estocástico es una **colección de variables aleatorias** indexadas tal que forman una secuencia. Se denotan matemáticamente como un conjunto $\\{U_k\\}$, con $k=0, 1, 2, \\ldots, N$. El índice $k$ puede representar tiempo, espacio u otra variable independiente.\n\nLa siguiente figura muestra tres realizaciones u observaciones de un proceso estocástico con cuatro elementos\n\n\n\nExisten muchos fenómenos cuya evolución se modela utilizando procesos aleatorios. Por ejemplo\n\n- Los índices bursatiles\n- El comportamineto de un gas dentro de un contenedor\n- Las vibraciones de un motor eléctrico\n- El área de una célula durante un proceso de organogénesis\n\nA continuación revisaremos algunas de las propiedades de los procesos aleatorios\n\n**Momentos de un proceso estocástico**\n\nUn proceso aleatorio $U_n = (u_n, u_{n-1}, u_{n-2}, \\ldots, u_{n-L})$ se describe a través de sus momentos estadísticos. Si consideramos una caracterízación de segundo orden necesitamos definir\n\n- Momento central o media: Describe el valor central del proceso\n\n$$\n\\mu(n) = \\mathbb{E}[U_n]\n$$\n\n- Segundo momento o correlación: Describe la dispersión de un proceso \n\n$$\nr_{uu}(n, n-k) = \\mathbb{E}[U_n U_{n-k}]\n$$\n\n- Segundo momento centrado o covarianza\n\n$$\n\\begin{align}\nc_{uu}(n, n-k) &= \\mathbb{E}[(U_n-\\mu_n) (U_{n-k}- \\mu_{n-k})] \\nonumber \\\\\n&= r(n,n-k) - \\mu_n \\mu_{n-k} \\nonumber\n\\end{align}\n$$\n\n- Correlación cruzada entre dos procesos \n\n$$\nr_{ud}(n, n-k) = \\mathbb{E}[U_n D_{n-k}]\n$$\n\n\n\n\n**Proceso estacionario y ergódico**\n\nEn esta lección nos vamos a centrar en el caso simplificado donde el **proceso es estacionario**, matemáticamente esta propiedad significa que\n\n$$\n\\mu(n) = \\mu, \\forall n\n$$\n\ny\n\n$$\nr_{uu}(n, n-k) = r_{uu}(k), \\forall n\n$$\n\nes decir que los momentos estadísticos se mantienen constantes en el tiempo (no depende de $n$).\n\nOtra simplificación que utilizaremos es que el proceso sea **ergódico**, \n\n$$\n\\mathbb{E}[U_n] = \\frac{1}{N} \\sum_{n=1}^N u_n\n$$\n\nes decir que podemos reemplazar el valor esperado por la media muestral en el tiempo\n\n\n**Densidad espectral de potencia**\n\nLa densidad espectral de potencia o *power spectral density* (PSD) mide la distribución en frecuencia de la potencia del proceso estocástico. Su definición matemática es\n\n$$\n\\begin{align}\nS_{uu}(f) &= \\sum_{k=-\\infty}^{\\infty} r_{uu}(k) e^{-j 2\\pi f k} \\nonumber \\\\\n&= \\lim_{N\\to\\infty} \\frac{1}{2N+1} \\mathbb{E} \\left [\\left|\\sum_{n=-N}^{N} u_n e^{-j 2\\pi f n} \\right|^2 \\right]\n\\end{align}\n$$\n\nque corresponde a la transformada de Fourier de la correlación (caso estacionario)\n\nLa PSD y la correlación forman un par de Fourier, es decir que uno es la transformada de Fourier del otro.\n\n## Filtro de Wiener\n\nEl filtro de Wiener fue publicado por Norbert Wiener en 1949 y es tal vez el ejemplo más famoso de un estimador lineal óptimo.\n\n:::{important}\n\nPara diseñar un estimador óptimo necesitamos un **criterio** y **condiciones** (supuestos). Luego el estimador será **óptimo según dicho criterio y bajo los supuestos considerados**. Por ejemplo podríamos suponer un escenario donde el ruido es blanco o donde el proceso es estacionario.\n\n:::\n\nA continuación describiremos en detalle este filtro y explicaremos como se optimiza. Luego se veran ejemplos de aplicaciones.\n\n\n\n\n\n### Notación y arquitectura del filtro de Wiener\n\nEl filtro de Wiener es un sistema de tiempo discreto con estructura FIR y $L+1$ coeficientes. A continuación se muestra un esquema del filtro de Wiener\n\n\n\n\n\nDel esquema podemos reconocer los elementos más importantes de este filtro\n\n- Los coeficientes del filtro: $h_0, h_1, h_2, \\ldots, h_{L}$\n- La señal de entrada al filtro: $u_0, u_1, u_2, \\ldots$\n- La señal de salida del filtro: $y_0, y_1, y_2, \\ldots$\n- La señal de respuesta \"deseada\" u objetivo: $d_0, d_1, d_2, \\ldots$\n- La señal de error: $e_0, e_1, e_2, \\ldots$\n\nAl ser un filtro FIR la salida del filtro está definida como\n\n$$\ny_n = \\sum_{k=0}^{L} h_k u_{n-k},\n$$\n\nes decir la convolución entre la entrada y los coeficientes. Luego la señal de error es\n\n$$\ne_n = d_n - y_n = d_n - \\sum_{k=0}^{L} h_k u_{n-k} \n$$\n\nque corresponde a la diferencia entre la señal objetivo y la señal de salida. \n\nA continuación veremos que se ajustan los coeficientes del filtro en base al criterio de optimalidad. \n\n\n### Ajuste del filtro de Wiener\n\nEl criterio más común para aprender o adaptar el filtro de Wiener es el **error medio cuadrático** o *mean square error* (MSE) entre la respuesta deseada y la salida del filtro.\n\nAsumiendo que $u$ y $d$ son secuencias de valores reales podemos escribir el MSE como\n\n$$\n\\begin{align}\n\\text{MSE} &= \\mathbb{E}\\left [e_n^2 \\right] \\nonumber \\\\\n&= \\mathbb{E}\\left [(d_n - y_n)^2 \\right] \\nonumber \\\\\n&= \\mathbb{E}\\left [d_n^2 \\right] - 2\\mathbb{E}\\left [ d_n y_n \\right] + \\mathbb{E}\\left [ y_n^2 \\right] \\nonumber \n\\end{align}\n$$\n\ndonde $\\sigma_d^2 = \\mathbb{E}\\left [d_n^2 \\right]$ es la varianza de la señal deseada y $\\sigma_y^2 = \\mathbb{E}\\left [ y_n^2 \\right]$ es la varianza de nuestro estimador\n \n:::{note}\n \nMinimizar el MSE implica acercar la salida del filtro a la respuesta deseada\n \n:::\n\nEn este caso, igualando la derivada del MSE a cero, tenemos \n\n$$\n\\begin{align}\n\\frac{d}{d h_j} \\text{MSE} &= -2\\mathbb{E}\\left[ d_n \\frac{d y_n}{d h_j} \\right] + 2 \\mathbb{E}\\left[ y_n \\frac{d y_n}{d h_j} \\right] \\nonumber \\\\\n&= -2\\mathbb{E}\\left[ d_n u_{n-j} \\right] + 2 \\mathbb{E}\\left[ y_n u_{n-j} \\right] \\nonumber \\\\\n&= -2\\mathbb{E}\\left[ d_n u_{n-j} \\right] + 2 \\mathbb{E}\\left[ \\sum_{k=0}^{L} h_k u_{n-k} u_{n-j} \\right] \\nonumber \\\\\n&= -2\\mathbb{E}\\left[ d_n u_{n-j} \\right] + 2 \\sum_{k=0}^{L} h_k \\mathbb{E}\\left[ u_{n-k} u_{n-j} \\right] = 0 \\nonumber \\end{align}\n$$\n\nSi despejamos y repetimos para $j=0, \\ldots, L$ obtenemos el siguiente sistema de ecuaciones\n\n$$\n\\begin{align}\n\\begin{pmatrix}\nr_{uu}(0) & r_{uu}(1) & r_{uu}(2) & \\ldots & r_{uu}(L) \\\\\nr_{uu}(1) & r_{uu}(0) & r_{uu}(1) & \\ldots & r_{uu}(L-1) \\\\\nr_{uu}(2) & r_{uu}(1) & r_{uu}(0) & \\ldots & r_{uu}(L-2) \\\\\n\\vdots & \\vdots & \\vdots & \\ddots &\\vdots \\\\\nr_{uu}(L) & r_{uu}(L-1) & r_{uu}(L-2) & \\ldots & r_{uu}(0) \\\\\n\\end{pmatrix}\n\\begin{pmatrix}\nh_0 \\\\\nh_1 \\\\\nh_2 \\\\\n\\vdots \\\\\nh_L \\\\\n\\end{pmatrix} &= \n\\begin{pmatrix}\nr_{ud}(0) \\\\\nr_{ud}(1) \\\\\nr_{ud}(2) \\\\\n\\vdots \\\\\nr_{ud}(L) \\\\\n\\end{pmatrix} \\nonumber \\\\\nR_{uu} \\textbf{h} &= R_{ud},\n\\end{align}\n$$\n\nque se conoce como las **ecuaciones de Wiener-Hopf**. Además $R_{uu}$ se conoce como matriz de auto-correlación. \n\nAsumiendo que $R_{uu}$ es no-singular, es decir que su inversa existe, la **solución óptima en el sentido de mínimo MSE** es \n\n$$\n\\textbf{h}^{*} = R_{uu} ^{-1} R_{ud}\n$$\n\n\nNotar que por construcción la matriz $R_{uu}$ es simétrica y hermítica. Por lo que el sistema puede resolverse de forma eficiente con $\\mathcal{O}(L^2)$ operaciones usando la [recursión de Levison-Durbin](https://en.wikipedia.org/wiki/Levinson_recursion) \n\n\n:::{warning}\n\nPara llegar a la solución impusimos dos condiciones sobre la salida deseada y la entrada: (1) tienen media cero y (2) son estacionarias en el sentido amplio (es decir la correlación solo depende del retardo $m$).\n\n:::\n\n- Si la primera condición no se cumpliera, podría restarse la media previo al entrenamiento del filtro\n- Si la segunda condición no se cumple conviene usar otro método como los que veremos en las lecciones siguientes\n\n## Aplicaciones del filtro de Wiener\n\n### Regresión o identificación de sistema\n\nEn regresión buscamos encontrar los coeficientes $h$ a partir de tuplas $(X, Y)$ tal que\n\n$$\nY = h^T X + \\epsilon,\n$$\n\ndonde $X \\in \\mathbb{R}^{N\\times D}$ son las variables dependientes (entrada), $Y \\in \\mathbb{R}^N$ es la variable dependiente (salida) y $\\epsilon$ es ruido\n\nPara entrenar el filtro\n\n1. Asumimos que hemos observado N muestras de $X$ e $Y$ \n1. A partir de $u=X$ construimos $R_{uu}$\n1. A partir de $d=Y$ construimos $R_{ud}$\n1. Finalmente recuperamos $\\textbf{h}$ usando $R_{uu} ^{-1} R_{ud}$\n1. Con esto podemos interpolar $Y$ \n\n\n\n**Ejemplo** Sea por ejemplo una regresión de tipo polinomial donde queremos encontrar $h_k$ tal que\n\n$$\n\\begin{align}\nd_i &= f_i + \\epsilon \\nonumber \\\\\n&= \\sum_{k=1}^L h_k u_i^k + \\epsilon \\nonumber\n\\end{align}\n$$\n\n\n```python\nnp.random.seed(12345)\nu = np.linspace(-2, 2, num=30)\nf = 0.25*u**5 - 2*u**3 + 5*u # Los coeficientes reales son [0, 5, 0, -2, 0, 1/4, 0, 0, 0, ...]\nd = f + np.random.randn(len(u))\n```\n\n\n```python\nhv.Points((u, d), kdims=['u', 'd'])\n```\n\nImplementemos el filtro como una clase con dos métodos públicos `fit` (ajustar) y `predict` (predecir). El filtro tiene un argumento, el número de coeficientes $L$\n\n\n```python\nclass Wiener_polynomial_regression:\n \n def __init__(self, L: int):\n self.L = L\n self.h = np.zeros(shape=(L+1,))\n \n def _polynomial_basis(self, u: np.ndarray) -> np.ndarray:\n U = np.ones(shape=(len(u), self.L))\n for i in range(1, self.L):\n U[:, i] = u**i\n return U\n \n def fit(self, u: np.ndarray, d: np.ndarray):\n U = self._polynomial_basis(u)\n Ruu = np.dot(U.T, U)\n Rud = np.dot(U.T, d[:, np.newaxis])\n self.h = scipy.linalg.solve(Ruu, Rud, assume_a='pos')[:, 0]\n \n def predict(self, u: np.ndarray):\n U = self._polynomial_basis(u)\n return np.dot(U, self.h)\n```\n\n:::{note}\n\nLa función `scipy.linalg.solve(A, B)` retorna la solución del sistema de ecuaciones lineal `Ax = B`. El argumento `assume_a` puede usarse para indicar que `A` es simétrica, hermítica o definido positiva.\n\n:::\n\nLos solución de un sistema con `10` coeficientes es:\n\n\n```python\nregressor = Wiener_polynomial_regression(10)\nregressor.fit(u, d)\nprint(regressor.h)\n```\n\n¿Cómo cambia el resultado con L?\n\n\n```python\nuhat = np.linspace(np.amin(u), np.amax(u), num=100)\nyhat = {}\nfor L in [2, 5, 15]:\n regressor = Wiener_polynomial_regression(L)\n regressor.fit(u, d)\n yhat[L] = regressor.predict(uhat)\n```\n\n\n```python\np = [hv.Points((u, d), kdims=['u', 'd'], label='data').opts(size=4, color='k')]\nfor L, prediction in yhat.items():\n p.append(hv.Curve((uhat, prediction), label=f'L={L}'))\nhv.Overlay(p).opts(legend_position='top') \n```\n\n:::{note}\n \nSi $L$ es muy pequeño el filtro es demasiado simple. Si $L$ es muy grande el filtro se puede sobreajustar al ruido\n \n:::\n\n### Predicción a futuro\n\nEn este caso asumimos que la señal deseada es la entrada en el futuro\n\n$$\nd_n = \\{u_{n+1}, u_{n+2}, \\ldots, u_{n+m}\\}\n$$ \n\ndonde $m$ es el horizonte de predicción. Se llama *predicción a un paso* al caso particular $m=1$.\n\nEl largo del filtro $L$ define la cantidad de muestras pasadas que usamos para predecir. Por ejemplo un sistema de predicción a un paso con $L+1 = 3$ coeficientes:\n\n$$\nh_0 u_n + h_1 u_{n-1} + h_2 u_{n-2}= y_n = \\hat u_{n+1} \\approx u_{n+1}\n$$\n\nPara entrenar el filtro\n\n1. Asumimos que la señal ha sido observada y que se cuenta con $N$ muestras para entrenar\n1. Podemos formar una matriz cuyas filas son $[u_n, u_{n-1}, \\ldots, u_{n-L}]$ para $n=L,L+1,\\ldots, N-1$\n1. Podemos formar un vector $[u_N, u_{N-1}, \\ldots, u_{L+1}]^T$ (caso $m=1$)\n1. Con esto podemos formar las matrices de correlación y obtener $\\textbf{h}$\n1. Finalmente usamos $\\textbf{h}$ para predecir el futuro no observado de $u$\n\nNuevamente implementamos el filtro como una clase. Esta vez se utiliza la función de numpy `as_strided` para formar los vectores de \"instantes pasados\"\n\n\n```python\nfrom numpy.lib.stride_tricks import as_strided\n\nclass Wiener_predictor:\n \n def __init__(self, L: int):\n self.L = L\n self.h = np.zeros(shape=(L+1,))\n \n def fit(self, u: np.ndarray):\n U = as_strided(u, [len(u)-self.L+1 , self.L+1], \n strides=[u.strides[0], u.strides[0]])\n Ruu = np.dot(U[:, :self.L].T, U[:, :self.L])\n Rud = np.dot(U[:, :self.L].T, U[:, self.L][:, np.newaxis])\n self.h = scipy.linalg.solve(Ruu, Rud, assume_a='pos')[:, 0]\n \n def predict(self, u: np.ndarray, m: int=1):\n u_pred = np.zeros(shape=(m+self.L, ))\n u_pred[:self.L] = u\n for k in range(self.L, m+L):\n u_pred[k] = np.sum(self.h*u_pred[k-self.L:k])\n return u_pred[self.L:]\n```\n\nPara la siguiente señal sinusoidal ¿Cómo afecta $L$ a la calidad del predictor lineal?\n\nUtilizaremos los primeros 100 instantes para ajustar y los siguientes 100 para probar el predictor\n\n\n```python\nnp.random.seed(12345)\nt = np.linspace(0, 10, num=200)\nu = np.sin(2.0*np.pi*0.5*t) + 0.25*np.random.randn(len(t))\nN_fit = 100\n\nyhat = {}\nfor L in [10, 20, 30]:\n predictor = Wiener_predictor(L)\n predictor.fit(u[:N_fit])\n yhat[L] = predictor.predict(u[N_fit-L:N_fit], m=100)\n \n```\n\n\n```python\np = [hv.Points((t, u), ['instante', 'u'], label='Datos').opts(color='k')]\nfor L, prediction in yhat.items():\n p.append(hv.Curve((t[N_fit:], prediction), label=f'L={L}'))\nhv.Overlay(p).opts(legend_position='top') \n```\n\n:::{note} \n\nSi $L$ es muy pequeño el filtro es demasiado simple. Si $L$ es muy grande el filtro se puede sobreajustar al ruido \n\n:::\n\n### Eliminar ruido blanco aditivo\n\nEn este caso asumimos que la señal de entrada corresponde a una señal deseada (información) que ha sido contaminada con ruido aditivo\n\n$$\nu_n = d_n + \\nu_n,\n$$\n\nadicionalmente asumimos que\n- el ruido es estacionario en el sentido amplio y de media cero $\\mathbb{E}[\\nu_n] = 0$\n- el ruido es blanco, es decir no tiene correlación consigo mismo o con la señal deseada\n\n$$\nr_{\\nu d}(k) = 0, \\forall k\n$$\n\n- el ruido tiene una cierta varianza $\\mathbb{E}[\\nu_n^2] = \\sigma_\\nu^2, \\forall n$\n\nNotemos que en este caso $R_{uu} = R_{dd} + R_{\\nu\\nu}$ y $R_{ud} = R_{dd}$, luego\n\nla señal recuperada es $\\hat d_n = h^{*} u_n$ y el filtro es\n\n$$\n\\vec h^{*} = \\frac{R_{dd}}{R_{dd} + R_{\\nu\\nu}}\n$$\n\ny su respuesta en frecuencia\n\n$$\nH(f) = \\frac{S_{dd}(f)}{S_{dd}(f) + S_{\\nu\\nu}(f)}\n$$\n\nes decir que \n- en frecuencias donde la $S_{dd}(f) > S_{\\nu\\nu}(f)$, entonces $H(f) = 1$\n- en frecuencias donde la $S_{dd}(f) < S_{\\nu\\nu}(f)$, entonces $H(f) = 0$\n\n\n```python\n\n```\n", "meta": {"hexsha": "2b04aa5a72a52b98485c8a8dfe94d01c7e3213d9", "size": 23448, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/unit3/lecture1.ipynb", "max_stars_repo_name": "phuijse/UACH-INFO183", "max_stars_repo_head_hexsha": "0e1b6bef0bd80cda2753bd11e62016268f2de638", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2018-08-27T23:53:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T23:31:05.000Z", "max_issues_repo_path": "lectures/unit3/lecture1.ipynb", "max_issues_repo_name": "phuijse/UACH-INFO183", "max_issues_repo_head_hexsha": "0e1b6bef0bd80cda2753bd11e62016268f2de638", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/unit3/lecture1.ipynb", "max_forks_repo_name": "phuijse/UACH-INFO183", "max_forks_repo_head_hexsha": "0e1b6bef0bd80cda2753bd11e62016268f2de638", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2019-01-04T17:43:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-07T16:07:18.000Z", "avg_line_length": 32.2087912088, "max_line_length": 295, "alphanum_fraction": 0.539107813, "converted": true, "num_tokens": 5122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3849121585956185, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.14110484672676116}}
{"text": "\n\n## Data-driven Design and Analyses of Structures and Materials (3dasm)\n\n## Lecture 5\n\n### Miguel A. Bessa | M.A.Bessa@tudelft.nl | Associate Professor\n\n**What:** A lecture of the \"3dasm\" course\n\n**Where:** This notebook comes from this [repository](https://github.com/bessagroup/3dasm_course)\n\n**Reference for entire course:** Murphy, Kevin P. *Probabilistic machine learning: an introduction*. MIT press, 2022. Available online [here](https://probml.github.io/pml-book/book1.html)\n\n**How:** We try to follow Murphy's book closely, but the sequence of Chapters and Sections is different. The intention is to use notebooks as an introduction to the topic and Murphy's book as a resource.\n* If working offline: Go through this notebook and read the book.\n* If attending class in person: listen to me (!) but also go through the notebook in your laptop at the same time. Read the book.\n* If attending lectures remotely: listen to me (!) via Zoom and (ideally) use two screens where you have the notebook open in 1 screen and you see the lectures on the other. Read the book.\n\n**Optional reference (the \"bible\" by the \"bishop\"... pun intended 😆) :** Bishop, Christopher M. *Pattern recognition and machine learning*. Springer Verlag, 2006.\n\n**References/resources to create this notebook:**\n* [Car figure](https://korkortonline.se/en/theory/reaction-braking-stopping/)\n\nApologies in advance if I missed some reference used in this notebook. Please contact me if that is the case, and I will gladly include it here.\n\n## **OPTION 1**. Run this notebook **locally in your computer**:\n1. Confirm that you have the 3dasm conda environment (see Lecture 1).\n\n2. Go to the 3dasm_course folder in your computer and pull the last updates of the [repository](https://github.com/bessagroup/3dasm_course):\n```\ngit pull\n```\n3. Open command window and load jupyter notebook (it will open in your internet browser):\n```\nconda activate 3dasm\njupyter notebook\n```\n4. Open notebook of this Lecture.\n\n## **OPTION 2**. Use **Google's Colab** (no installation required, but times out if idle):\n\n1. go to https://colab.research.google.com\n2. login\n3. File > Open notebook\n4. click on Github (no need to login or authorize anything)\n5. paste the git link: https://github.com/bessagroup/3dasm_course\n6. click search and then click on the notebook for this Lecture.\n\n\n```python\n# Basic plotting tools needed in Python.\n\nimport matplotlib.pyplot as plt # import plotting tools to create figures\nimport numpy as np # import numpy to handle a lot of things!\nfrom IPython.display import display, Math # to print with Latex math\n\n%config InlineBackend.figure_format = \"retina\" # render higher resolution images in the notebook\nplt.style.use(\"seaborn\") # style for plotting that comes from seaborn\nplt.rcParams[\"figure.figsize\"] = (8,4) # rescale figure size appropriately for slides\n```\n\n## Outline for today\n\n* Bayesian inference for one hidden rv\n - Prior\n - Likelihood\n - Marginal likelihood\n - Posterior\n - Gaussian pdf's product\n\n**Reading material**: This notebook + Chapter 3\n\n### Recall the \"slightly more complicated\" car stopping distance problem (with two rv's)\n\nWe defined the governing model with two rv's $z_1$ and $z_2$ as:\n\n$\\require{color}{\\color{red}y} = {\\color{blue}z_1}\\cdot x + {\\color{magenta}z_2}\\cdot x^2$\n\n- ${\\color{red}y}$ is the **output**: the car stopping distance (in meters)\n- ${\\color{blue}z_1}$ is an rv representing the driver's reaction time (in seconds)\n- ${\\color{magenta}z_2}$ is another rv that depends on the coefficient of friction, the inclination of the road, the weather, etc. (in m$^{-1}$s$^{-2}$).\n- $x$ is the **input**: constant car velocity (in m/s).\n\nwhere we knew the \"true\" distributions of the rv's: $z_1 \\sim \\mathcal{N}(\\mu_{z_1}=1.5,\\sigma_{z_1}^2=0.5^2)$, and $z_2 \\sim \\mathcal{N}(\\mu_{z_2}=0.1,\\sigma_{z_2}^2=0.01^2)$.\n\n\n```python\n# This cell is hidden during presentation. It's just to define a function to plot the governing model of\n# the car stopping distance problem. Defining a function that creates a plot allows to repeatedly run\n# this function on cells used in this notebook.\ndef car_fig_2rvs(ax):\n x = np.linspace(3, 83, 1000)\n mu_z1 = 1.5; sigma_z1 = 0.5; # parameters of the \"true\" p(z_1)\n mu_z2 = 0.1; sigma_z2 = 0.01; # parameters of the \"true\" p(z_2)\n mu_y = mu_z1*x + mu_z2*x**2 # From Homework of Lecture 4\n sigma_y = np.sqrt( (x*sigma_z1)**2 + (x**2*sigma_z2)**2 ) # From Homework of Lecture 4\n ax.set_xlabel(\"x (m/s)\", fontsize=20) # create x-axis label with font size 20\n ax.set_ylabel(\"y (m)\", fontsize=20) # create y-axis label with font size 20\n ax.set_title(\"Car stopping distance problem with two rv's\", fontsize=20); # create title with font size 20\n ax.plot(x, mu_y, 'k:', label=\"Governing model $\\mu_y$\")\n ax.fill_between(x, mu_y - 1.9600 * sigma_y,\n mu_y + 1.9600 * sigma_y,\n color='k', alpha=0.2,\n label='95% confidence interval ($\\mu_y \\pm 1.96\\sigma_y$)') # plot 95% credence interval\n ax.legend(fontsize=15)\n```\n\n\n```python\n# This cell is also hidden during presentation.\nfrom scipy.stats import norm # import the normal dist, as we learned before!\ndef samples_y_with_2rvs(N_samples,x): # observations/measurements/samples for car stop. dist. prob. with 2 rv's\n mu_z1 = 1.5; sigma_z1 = 0.5;\n mu_z2 = 0.1; sigma_z2 = 0.01;\n samples_z1 = norm.rvs(mu_z1, sigma_z1, size=N_samples) # randomly draw samples from the normal dist.\n samples_z2 = norm.rvs(mu_z2, sigma_z2, size=N_samples) # randomly draw samples from the normal dist.\n samples_y = samples_z1*x + samples_z2*x**2 # compute the stopping distance for samples of z_1 and z_2\n return samples_y # return samples of y\n```\n\n\n```python\n# vvvvvvvvvvv this is just a trick so that we can run this cell multiple times vvvvvvvvvvv\nfig_car_new, ax_car_new = plt.subplots(1,2); plt.close() # create figure and close it\nif fig_car_new.get_axes():\n del ax_car_new; del fig_car_new # delete figure and axes if they exist\n fig_car_new, ax_car_new = plt.subplots(1,2) # create them again\n# ^^^^^^^^^^^ end of the trick ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nN_samples = 3 # CHANGE THIS NUMBER AND RE-RUN THE CELL\nx = 75; empirical_y = samples_y_with_2rvs(N_samples, x); # Empirical measurements of N_samples at x=75\nempirical_mu_y = np.mean(empirical_y); empirical_sigma_y = np.std(empirical_y); # empirical mean and std\ncar_fig_2rvs(ax_car_new[0]) # a function I created to include the background plot of the governing model\nfor i in range(2): # create two plots (one is zooming in on the error bar)\n ax_car_new[i].errorbar(x , empirical_mu_y,yerr=1.96*empirical_sigma_y, fmt='m*', markersize=15);\n ax_car_new[i].scatter(x*np.ones_like(empirical_y),empirical_y, s=40,\n facecolors='none', edgecolors='k', linewidths=2.0)\nprint(\"Empirical mean[y] is\",empirical_mu_y, \"(real mean[y]=675)\")\nprint(\"Empirical std[y] is\",empirical_sigma_y,\"(real std[y]=67.6)\")\nfig_car_new.set_size_inches(25, 5) # scale figure to be wider (since there are 2 subplots)\n```\n\n### Note: comparison of car stopping distance problem of Lecture 3 & Lecture 4\n\n* The car stopping distance problem in Lecture 3 only had one rv.\n* While this car stopping distance problem (introduced in Lecture 4) **has 2 rv's**.\n - Observing the governing model when knowing the \"true\" distributions of $z_1$ and $z_2$ we see that:\n * The expected value (mean) of $y$ is the same for both problems because $\\mu_{z_2}=0.1$.\n * The variance of $y$ is higher for this problem because of the additional randomness introduced by $z_2$.\n - For example, for $x=75$ m/s the $\\text{std}[y] \\approx 67.6$ m while it was 37.5 when only $z_1$ was an rv.\n\n### Car stopping distance problem with 2 rv's but only 1 rv being unknown\n\n\n\nToday we will finally do some predictions!\n\nRecall the Homework of Lecture 4, and consider the car stopping distance problem for constant velocity $x=75$ m/s and for which **it is known** that $z_2 \\sim \\mathcal{N}(z_2|\\mu_{z_2}=0.1,\\sigma_{z_2}^2=0.01^2)$.\n\nThe only information that we do not know is the driver's reaction time $z$ (here we call it $z$, instead of $z_1$ as in Lecture 4, because this is the only hidden variable so we can **simplify the notation**).\n\n* Can we predict $p(y)$ without knowing $p(z)$?\n\nYes!! If we use Bayes' rule!\n\n### Recall the Homework of Lecture 4\n\n\n\nFrom last lecture's Homework, you demonstrated that the conditional pdf of the stopping distance given the reaction time $z$ (for convenience we write here $z$ instead of $z_1$) is\n\n$$\np(y|z) = \\mathcal{N}\\left(y | \\mu_{y|z}=w z+b, \\sigma_{y|z}^2=s^2\\right)\n$$\n\nwhere $w$, $b$ and $s$ are all constants that you determined to be:\n\n$w=x=75$\n\n$b=x^2\\mu_{z_2}=75^2\\cdot0.1=562.5$\n\n$s^2=(x^2 \\sigma_{z_2})^2=(75^2\\cdot0.01)^2=56.25^2$\n\nbecause we are considering that the car is going at constant velocity $x=75$ m/s and that we know $z_2= \\mathcal{N}(z_2|\\mu_{z_2}=0.1,\\sigma_{z_2}^2=0.01^2)$.\n\n### Solution to Homework of Lecture 4\n\n\n\nWhat we know:\n\n$\\require{color}{\\color{red}y} = {\\color{blue}z_1}\\cdot 75 + {\\color{magenta}z_2}\\cdot 75^2 = 75 {\\color{blue}z_1} + 5625 {\\color{magenta}z_2}$\n\nwhere $z_1 \\sim \\mathcal{N}(\\mu_{z_1}=1.5,\\sigma_{z_1}^2=0.5^2)$, and $z_2 \\sim \\mathcal{N}(\\mu_{z_2}=0.1,\\sigma_{z_2}^2=0.01^2)$.\n\n1. To calculate the conditional pdf $p(y|z_1)$, i.e. the observation distribution, we note that when given $z_1$ we just have $y$ as a function of $z_2$:\n\n$$\ny \\equiv f(z_2) = x z_1 + x^2 z_2 \\Rightarrow z_2 = \\frac{y}{x^2}-\\frac{z_1}{x} \\equiv g(y)\n$$\n\nFrom the change of variables formula (Lecture 3),\n\n$$\\begin{align}\np_{y|z_1}(y) &= p_{z_2}\\left( g(y) \\right) \\left| \\frac{d}{dy}g(y)\\right| \\\\\n&= \\mathcal{N}\\left( \\frac{y}{x^2}-\\frac{z_1}{x}\\left| \\mu_{z_2}, \\sigma_{z_2}^2\\right.\\right) \\left|\\frac{1}{x^2}\\right| \\\\\n&= \\frac{1}{\\sqrt{2\\pi \\sigma_{z_2}^2}} \\exp\\left[ -\\frac{1}{2\\sigma_{z_2}^2}\\left( \\frac{y}{x^2}-\\frac{z_1}{x}-\\mu_{z_2} \\right)^2 \\right] \\left|\\frac{1}{x^2}\\right|\\\\\n&= \\frac{1}{\\sqrt{2\\pi \\left(x^2\\sigma_{z_2}\\right)^2}} \\exp\\left[ -\\frac{1}{2\\left(x^2\\sigma_{z_2}\\right)^2}\\left( y-x z_1-x^2\\mu_{z_2} \\right)^2 \\right] \n\\end{align}\n$$\n\nSo, the conditional pdf $p(y|z_1)$ is also a Gaussian:\n\n$$\np(y|z_1) = \\mathcal{N}\\left( y| \\mu_{y|z_1}=x^2\\mu_{z_2}+x z_1, \\sigma_{y|z_1}=\\left( x^2 \\sigma_{z_2}\\right)^2 \\right)\n$$\n\n(Alternative way to answer Question 1 without using the change of variables formula)\n\nThere is a different way to derive the same result without even using the change of variables formula. We can obtain the same result as above by calculating the joint distribution $p(y,z_1,z_2)$:\n$$\\begin{align}\np(y,z_1,z_2) &= p(y|z_1, z_2) p(z_1, z_2) \\\\\n&= p(y|z_1,z_2) p(z_1) p(z_2) \\\\\n&= \\delta(y-x z_1 - x^2 z_2) p(z_1) p(z_2) \\\\\n&= \\frac{1}{|x^2|} \\delta(\\frac{y-x z_1}{x^2} - z_2) p(z_1) p(z_2) \\\\\n&= \\frac{1}{|x^2|} p_{z_2}(\\frac{y-x z_1}{x^2}) p(z_1) \\\\\n&= \\mathcal{N}\\left( y| x^2\\mu_{z_2}+x z_1, \\left( x^2 \\sigma_{z_2}\\right)^2 \\right) p(z_1)\n\\end{align}\n$$\n\n\n2. The joint distribution is simply $p(y, z_1)$:\n\n$$\np(y, z_1) = p(y|z_1)p(z_1) = \\mathcal{N}\\left( y| \\mu_{y|z_1}=x^2\\mu_{z_2}+x z_1, \\sigma_{y|z_1}=\\left( x^2 \\sigma_{z_2}\\right)^2 \\right) \\mathcal{N}\\left( z_1| \\mu_{z_1}=1.5, \\sigma_{z_1}=0.5^2 \\right)\n$$\n\nwhich we will learn how to calculate in this lecture (spoiler alert: it's another gaussian 😆)\n\n3. The covariance matrix is calculated as:\n\n$\n\\mathbb{E}[z_1] = \\mu_{z_1} \\, , \\quad \\mathbb{V}[z_1] = \\sigma_{z_1}^2\n$\n\n$\n\\mathbb{E}[y] = \\mathbb{E}[z_1 x + x^2 z_2]=\\mathbb{E}[z_1]x + x^2 \\mathbb{E}[z_2] = x\\mu_{z_1}+x^2\\mu_{z_2}\n$\n\n$\\begin{align}\n\\mathbb{E}[y^2] &= \\mathbb{E}\\left[ (z_1 x + x^2 z_2)(z_1 x + x^2 z_2) \\right]\\\\\n&= \\mathbb{E}\\left[ z_1^2 x^2+2x^3z_1 z_2 + x^4 z_2^2 \\right] \\\\\n&= x^2 \\mathbb{E}[z_1^2] + 2x^3 \\mathbb{E}[z_1 z_2] + x^4 \\mathbb{E}[z_2^2] \\\\\n&= x^2\\left( \\sigma_{z_1}^2 + \\mu_{z_1}^2\\right) + 2x^3 \\mu_{z_1}\\mu_{z_2} + x^4\\left( \\sigma_{z_2}^2 + \\mu_{z_2}^2\\right)\n\\end{align}\n$\n\n$\\begin{align}\n\\mathbb{V}[y] &= \\mathbb{E}[y^2]-\\mathbb{E}[y]^2\\\\\n&= x^2\\left( \\sigma_{z_1}^2 + \\mu_{z_1}^2\\right) + 2x^3 \\mu_{z_1}\\mu_{z_2} + x^4\\left( \\sigma_{z_2}^2 + \\mu_{z_2}^2\\right) - \\left( x\\mu_{z_1}+x^2\\mu_{z_2}\\right)^2 \\\\\n&= \\left( x\\sigma_{z_1}\\right)^2+\\left(x^2\\sigma_{z_2}\\right)^2 \\\\\n\\end{align}\n$\n\n$\\begin{align}\n\\text{Cov}[y, z_1] &= \\mathbb{E}[y z_1] - \\mathbb{E}[y] \\mathbb{E}[z_1] \\\\\n&= \\mathbb{E}[z_1^2 x + x^2 z_2 z_1] - \\left(x\\mu_{z_1}+x^2\\mu_{z_2}\\right) \\mu_{z_1} \\\\\n&= x\\mathbb{E}[z_1^2]+x^2\\mathbb{E}[z_1 z_2] - \\left(x\\mu_{z_1}+x^2\\mu_{z_2}\\right) \\mu_{z_1} \\\\\n&= x\\left( \\sigma_{z_1}^2 + \\mu_{z_1}^2\\right)+x^2\\mu_{z_1}\\mu_{z_2} - x\\mu_{z_1}-x^2x\\mu_{z_1}\\mu_{z_2} \\\\\n&= x\\sigma_{z_1}^2\n\\end{align}\n$\n\nFrom where we can finally calculate the Covariance matrix:\n\n$$\n\\begin{align}\n\\boldsymbol{\\Sigma} &= \\text{Cov}\\begin{bmatrix}y\\\\ z_1\\end{bmatrix}\n = \\begin{bmatrix}\n\\mathbb{V}[y] & \\text{Cov}[y,z_1] \\\\\n\\text{Cov}[z_1,y] & \\mathbb{V}[z_1]\n\\end{bmatrix}\\\\\n&= \\begin{bmatrix}\n\\left( x\\sigma_{z_1}\\right)^2+\\left(x^2\\sigma_{z_2}\\right)^2 & x\\sigma_{z_1}^2 \\\\\nx\\sigma_{z_1}^2 & \\sigma_{z_1}^2\n\\end{bmatrix}\n\\end{align}\n$$\n\n### Understanding the Bayes' rule\n\n$\\require{color}$\n$$\n{\\color{green}p(z|y)} = \\frac{ {\\color{blue}p(y|z)}{\\color{red}p(z)} } {p(y)}\n$$\n\n* ${\\color{red}p(z)}$ is the **prior distribution**\n* ${\\color{blue}p(y|z)}$ is the **observation distribution** (conditional pdf)\n* $p(y)$ is the **marginal distribution**\n* ${\\color{green}p(z|y)}$ is the **posterior distribution**\n\n### A note about the term \"distribution\"\n\nThe term distribution can mean two things:\n1. For **continuous** rv's , the term *distribution* means *probability density function* (pdf ).\n\n2. For **discrete** rv's the term *distribution* means *probability mass function* (pmf ), as we will see later in the course.\n\nWe won't talk about categorical distributions or pmf's for a while. So, for now, when you see the term *distribution* it is the same as saying pdf .\n\n### Understanding the Bayes' rule\n\nLet's start by understanding the usefulness of Bayes' rule by calculating the posterior $p(z|y)$ for the car stopping distance problem (Homework of Lecture 4).\n\nAs we mentioned, for our problem we know the **observation distribution**:\n\n$p(y|z) = \\mathcal{N}\\left(y | \\mu_{y|z}=w z+b, \\sigma_{y|z}^2\\right)$\n\nwhere $\\sigma_{y|z} = \\text{const}$, as well as $w$ and $b$. \n\nbut we **don't know** the prior $p(z)$.\n\n### Prior: our beliefs about the problem\n\nIf we have absolutely no clue about what the distribution of the hidden rv $z$ is, then we can use a **Uniform distribution** (a.k.a. uninformative prior).\n\nThis distribution assigns equal probability to any value of $z$ within an interval $z \\in (z_{min}, z_{max})$.\n\n$$\np(z) = \\frac{1}{C_z}\n$$\n\nwhere $C_z = z_{max}-z_{min}$ is the **normalization constant** of the Uniform pdf, i.e. the value that guarantees that $p(z)$ integrates to one.\n\nFor the time being, we will not assume any particular values for $z_{max}$ and $z_{min}$. So, we will consider the completely uninformative prior: $z_{max}\\rightarrow \\infty$ and $z_{min}\\rightarrow -\\infty$. If we had some information, we could consider some values for these bounds (e.g. $z_{min} = 0$ seconds would be the limit of the fastest reaction time that is humanly possible, and $z_{max} = 3$ seconds would be the slowest reaction time of a human being).\n\n### Summary of our Model\n\n1. The **observation distribution**:\n\n$$\\begin{align}\np(y|z) &= \\mathcal{N}\\left(y | \\mu_{y|z}=w z+b, \\sigma_{y|z}^2\\right) \\\\\n&= \\frac{1}{C_{y|z}} \\exp\\left[ -\\frac{1}{2\\sigma_{y|z}^2}(y-\\mu_{y|z})^2\\right]\n\\end{align}\n$$\n\nwhere $C_{y|z} = \\sqrt{2\\pi \\sigma_{y|z}^2}$ is the **normalization constant** of the Gaussian pdf, and where $\\mu_{y|z}=w z+b$, with $w$, $b$ and $\\sigma_{y|z}^2$ being constants, as previously mentioned.\n\n2. and the **prior distribution**: $p(z) = \\frac{1}{C_z}$\n\nwhere $C_z = z_{max}-z_{min}$ is the **normalization constant** of the Uniform pdf, i.e. the value that guarantees that $p(z)$ integrates to one.\n\n### Posterior from Bayes' rule\n\nSince we have defined the **observation distribution** and the **prior distribution**, we can now compute the posterior distribution from Bayes' rule.\n\nBut this requires a bit of algebra... Let's do it!\n\nFirst, in order to apply Bayes' rule $p(z|y) = \\frac{ p(y|z)p(z)}{p(y)}$ we need to calculate $p(y)$.\n\n$p(y)$ is obtained by marginalizing the joint distribution wrt $z$:\n\n$\np(y) = \\int p(y|z)p(z) dz\n$\n\nwhich implies an integration over $z$. So, let's rewrite $p(y|z)$ so that the integration becomes easier.\n\n$$\\begin{align}\np(y|z) &= \\mathcal{N}\\left(y | \\mu_{y|z}=w z+b, \\sigma_{y|z}^2\\right) \\\\\n&= \\frac{1}{C_{y|z}} \\exp\\left[ -\\frac{1}{2\\sigma_{y|z}^2}(y-(w z+b))^2\\right] \\\\\n&= \\frac{1}{C_{y|z}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\} \\\\\n&= \\frac{1}{|w|}\\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\}\n\\end{align}\n$$\n\nNote: This Gaussian pdf $\\mathcal{N}\\left(z | \\frac{y-b}{w}, \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2\\right)$ is unnormalized when written wrt $z$ (due to $\\frac{1}{|w|}$).\n\nWe can now calculate the marginal distribution $p(y)$:\n\n$$\n\\begin{align}\np(y) &= \\int p(y|z)p(z) dz \\\\\n&= \\int \\frac{1}{|w|}\\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\} \\frac{1}{C_z} dz\n\\end{align}\n$$\n\nWe can rewrite this expression as,\n\n$$\\require{color}\n\\begin{align}\np(y) &= \\frac{1}{|w|\\cdot C_z} {\\color{blue}\\int \\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\} dz} \\\\\n\\end{align}\n$$\n\nWhat is the result for the blue term ?\n\nFrom where we conclude that the marginal distribution is:\n\n$$\\require{color}\np(y) = \\frac{1}{|w| C_z }\n$$\n\nSo, now we can determine the posterior:\n\n$$\\require{color}\n\\begin{align}\np(z|y) &= \\frac{ p(y|z)p(z)}{p(y)} \\\\\n&= |w| C_z \\cdot \\frac{1}{|w|}\\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\} \\cdot \\frac{1}{C_z}\\\\\n&= \\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}}\\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\}\n\\end{align}\n$$\n\nwhich is a **normalized** Gaussian pdf in $z$: $\\mathcal{N}\\left(z | \\frac{y-b}{w}, \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2\\right)$\n\n* **This is what the Bayes' rule does!** Computes the posterior $p(z|y)$ from $p(y|z)$ and $p(z)$.\n\n## Why should we care about the Bayes' rule?\n\nThere are a few reasons:\n\n1. As we will see, models are usually (always?) wrong.\n\n\n2. But our beliefs may be a bit closer to reality! Bayes' rule enables us to get better models if our beliefs are reasonable!\n\n\n3. We don't observe distributions. We observe **DATA**. Bayes' rule is a very powerful way to predict the distribution of our quantity of interest (here: $y$) from data!\n\n## Bayes' rule applied to observed data\n\nPreviously, we already introduced Bayes' rule when applied to observed data $\\mathcal{D}_y$.\n\n$\\require{color}$\n$$\n{\\color{green}p(z|y=\\mathcal{D}_y)} = \\frac{ {\\color{blue}p(y=\\mathcal{D}_y|z)}{\\color{red}p(z)} } {p(y=\\mathcal{D}_y)} = \\frac{ {\\color{magenta}p(y=\\mathcal{D}_y, z)} } {p(y=\\mathcal{D}_y)}\n$$\n\n* ${\\color{red}p(z)}$ is the **prior** distribution\n* ${\\color{blue}p(y=\\mathcal{D}_y|z)}$ is the **likelihood** function\n* ${\\color{magenta}p(y=\\mathcal{D}_y, z)}$ is the **joint likelihood** (product of likelihood function with prior distribution)\n* $p(y=\\mathcal{D}_y)$ is the **marginal likelihood**\n* ${\\color{green}p(z|y=\\mathcal{D}_y)}$ is the **posterior**\n\nWe can write Bayes' rule as posterior $\\propto$ likelihood $\\times$ prior , where we are ignoring the denominator $p(y=\\mathcal{D}_y)$ because it is just a **constant** independent of the hidden variable $z$.\n\n## Bayes' rule applied to observed data\n\nBut remember that Bayes' rule is just a way to calculate the posterior:\n\n$$\np(z|y=\\mathcal{D}_y) = \\frac{ p(y=\\mathcal{D}_y|z)p(z) } {p(y=\\mathcal{D}_y)}\n$$\n\nUsually, what we really want is to be able to predict the distribution of the quantity of interest (here: $y$) after observing some data $\\mathcal{D}_y$:\n\n$$\\require{color}\n{\\color{orange}p(y|y=\\mathcal{D}_y)} = \\int p(y|z) p(z|y=\\mathcal{D}_y) dz\n$$\n\nwhich is often written in simpler notation: $p(y|\\mathcal{D}_y) = \\int p(y|z) p(z|\\mathcal{D}_y) dz$\n\n### Bayesian inference for car stopping distance problem\n\nNow we will solve the first Bayesian ML problem from some given data $y=\\mathcal{D}_y$:\n\n| $y_i$ (m) |\n| ---- |\n| 601.5 |\n| 705.9 |\n| 693.8 |\n| ... |\n| 711.3 |\n\nwhere the data $\\mathcal{D}_y$ could be a Pandas dataframe with $N$ data points ($N$ rows).\n\n* **Very Important Question (VIQ)**: Can we calculate the **likelihood** function from this data?\n\n### Likelihood for car stopping distance problem\n\nOf course! As we saw a few cells ago, the **likelihood** is obtained by evaluating the **observation distribution** at the data $\\mathcal{D}_y$.\n\nNoting that each observation in $\\mathcal{D}_y$ is independent of each other, then:\n\n$$\np(y=\\mathcal{D}_y | z) = \\prod_{i=1}^{N} p(y=y_i|z) = p(y=y_1|z)p(y=y_2|z) \\cdots p(y=y_N|z)\n$$\n\nwhich gives the **probability density** of observing that data if using our observation distribution (part of our model!).\n\n#### Calculating the likelihood\n\nLet's calculate it:\n\n$$\n\\begin{align}\np(y=\\mathcal{D}_y | z) &= \\prod_{i=1}^{N} p(y=y_i|z) \\\\\n&= \\prod_{i=1}^{N} \\frac{1}{C_{y|z}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y_i-b}{w}\\right)\\right]^2\\right\\}\n\\end{align}\n$$\n\nThis seems a bit daunting... I know. Do not dispair yet!\n\n##### Product of Gaussian pdf's of the same rv $z$\n\nIt can be shown that the product of $N$ univariate Gaussian pdf's of the same rv $z$ is:\n\n$$\n\\prod_{i=1}^{N} \\mathcal{N}(z|\\mu_i, \\sigma_i^2) = C \\cdot \\mathcal{N}(z|\\mu, \\sigma^2)\n$$\n\nwith mean: $\\mu = \\sigma^2 \\left( \\sum_{i=1}^{N} \\frac{\\mu_i}{\\sigma_i^2}\\right)$\n\nvariance: $\\sigma^2= \\frac{1}{\\sum_{i=1}^{N} \\frac{1}{\\sigma_i^2}}$\n\nand normalization constant: $C = \\frac{1}{\\left(2\\pi\\right)^{(N-1)/2}}\\sqrt{\\frac{\\sigma^2}{\\prod_{i=1}^N \\sigma_i^2}} \\exp\\left[-\\frac{1}{2}\\left(\\sum_{i=1}^{N} \\frac{\\mu_i^2}{\\sigma_i^2} - \\frac{\\mu^2}{\\sigma^2}\\right)\\right]$\n\nCuriosity: the normalization constant $C$ is itself a Gaussian! You can see it more clearly if you consider $N=2$\n\nNote that the normalization constant shown in the previous cell can also be written as:\n\n$$\nC = \\frac{1}{\\left(2\\pi\\right)^{(N-1)/2}}\\sqrt{\\frac{\\sigma^2}{\\prod_{i=1}^N \\sigma_i^2}} \\exp\\left[-\\frac{1}{2}\\left(\\sum_{i=1}^{N-1}\\sum_{j=i+1}^{N} \\frac{(\\mu_i-\\mu_j)^2}{\\sigma_i^2 \\sigma_j^2}\\sigma^2\\right)\\right]\n$$\n\n# HOMEWORK \n\nShow that the product of two Gaussian pdf's for the same rv $z$ is:\n\n$\\mathcal{N}(z|\\mu_1, \\sigma_1^2)\\cdot \\mathcal{N}(z|\\mu_2, \\sigma_2^2)= C \\cdot \\mathcal{N}(z | \\mu, \\sigma^2)$\n\n$$\n\\begin{align}\n\\sigma^2&=\\frac{1}{\\frac{1}{\\sigma_1^2}+\\frac{1}{\\sigma_2^2}}\\\\\n\\mu&=\\sigma^2\\left(\\frac{\\mu_1}{\\sigma_1^2} + \\frac{\\mu_2}{\\sigma_2^2}\\right)\\\\\nC &= \\frac{1}{\\sqrt{2\\pi(\\sigma_1^2+\\sigma_2^2)}} \\exp\\left[-\\frac{1}{2(\\sigma_1^2+\\sigma_2^2)}(\\mu_1-\\mu_2)^2\\right]\n\\end{align}\n$$\n\n#### Side note\n\nIt's interesting to note that the product of MVN's for the same rv's $\\mathbf{z}$ is also a Gaussian!\n\nTo keep things simple, here's the result for the product of 2 Gaussian pdf's:\n\n$\\mathcal{N}(\\mathbf{z}|\\boldsymbol{\\mu}_1, \\boldsymbol{\\Sigma}_1)\\cdot \\mathcal{N}(\\mathbf{z}|\\boldsymbol{\\mu}_2, \\boldsymbol{\\Sigma}_2)= C \\cdot \\mathcal{N}(\\mathbf{z} | \\boldsymbol{\\mu}, \\boldsymbol{\\Sigma})$\n\nwhere\n\n$\\boldsymbol{\\mu} = \\boldsymbol{\\Sigma}\\left(\\boldsymbol{\\Sigma}_1^{-1}\\boldsymbol{\\mu}_1 + \\boldsymbol{\\Sigma}_2^{-1}\\boldsymbol{\\mu}_2 \\right)$\n\n$\\boldsymbol{\\Sigma} = \\left( \\boldsymbol{\\Sigma}_1^{-1}+\\boldsymbol{\\Sigma}_2^{-1}\\right)^{-1}$\n\n$\n\\begin{align}\nC &= \\mathcal{N}_{\\boldsymbol{\\mu}_1}\\left(\\boldsymbol{\\mu}_2, \\left( \\boldsymbol{\\Sigma}_1+\\boldsymbol{\\Sigma}_2\\right)\\right)\\\\\n&= \\frac{1}{\\sqrt{\\det[2\\pi \\left( \\boldsymbol{\\Sigma}_1+\\boldsymbol{\\Sigma}_2 \\right)]}} \\exp\\left[-\\frac{1}{2} \\left( \\boldsymbol{\\mu}_1-\\boldsymbol{\\mu}_2\\right)^T\\cdot\\left( \\boldsymbol{\\Sigma}_1+\\boldsymbol{\\Sigma}_2 \\right)^{-1}\\left( \\boldsymbol{\\mu}_1-\\boldsymbol{\\mu}_2 \\right) \\right]\\\\\n\\end{align}\n$\n\n#### Back to calculating the likelihood\n\n$$\n\\begin{align}\np(y=\\mathcal{D}_y | z) &= \\prod_{i=1}^{N} p(y=y_i|z) \\\\\n&= \\prod_{i=1}^{N} \\frac{1}{|w|} \\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y_i-b}{w}\\right)\\right]^2\\right\\} \\\\\n&= \\frac{1}{|w|^N} \\prod_{i=1}^{N} \\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y_i-b}{w}\\right)\\right]^2\\right\\}\n\\end{align}\n$$\n\nSo, using the result of a product of $N$ Gaussian pdf's to calculate the likelihood, and noting that $\\sigma_i = \\frac{\\sigma_{y|z}}{w}$ and $\\mu_i = \\frac{y_i - b}{w}$ we get:\n\n$$\np(y=\\mathcal{D}_y | z) = \\frac{1}{|w|^N} \\cdot C \\cdot \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp\\left[ -\\frac{1}{2\\sigma^2}(z-\\mu)^2\\right]\n$$\n\nwhere\n\n$\\mu = \\frac{\\sigma^2}{\\sigma_i^2} \\sum_{i=1}^N \\mu_i = \\frac{w^2\\sigma^2}{\\sigma_{y|z}^2} \\sum_{i=1}^N \\mu_i$\n\n$\\sigma^2 = \\frac{1}{ \\sum_{i=1}^N \\frac{1}{\\sigma_i^2} } = \\frac{1}{ \\sum_{i=1}^N \\frac{w^2}{\\sigma_{y|z}^2} } = \\frac{\\sigma_{y|z}^2}{w^2 N}$\n\n$\nC = \\frac{1}{\\left(2\\pi\\right)^{(N-1)/2}} \\sqrt{\\frac{\\sigma^2}{\\left( \\frac{\\sigma_{y|z}^2}{w^2}\\right)^N}} \\exp\\left[-\\frac{1}{2}\\left(\\frac{w^2}{\\sigma_{y|z}^2}\\sum_{i=1}^N \\mu_i - \\frac{\\mu^2}{\\sigma^2}\\right) \\right] = \\frac{1}{\\left(2\\pi\\right)^{(N-1)/2}} \\sqrt{\\frac{\\sigma^2}{\\left( \\frac{\\sigma_{y|z}^2}{w^2}\\right)^N}} \n$\n\n#### Calculating the marginal likelihood\n\n$$\\begin{align}\np(y=\\mathcal{D}_y) &= \\int p(y=\\mathcal{D}_y | z) p(z) dz \\\\\n&= \\int \\frac{1}{|w|^N} C \\cdot \\mathcal{N}(z|\\mu, \\sigma^2)\\cdot \\frac{1}{C_z} dz\\\\\n&= \\frac{C}{|w|^N C_z} \\int \\mathcal{N}(z|\\mu, \\sigma^2)dz = \\frac{C}{|w|^N C_z} \\\\\n\\end{align}\n$$\n\nWe can now calculate the posterior:\n\n$$\\begin{align}\np(z|y=\\mathcal{D}_y) &= \\frac{ p(y=\\mathcal{D}_y|z)p(z) } {p(y=\\mathcal{D}_y)} \\\\\n&= \\frac{1}{p(y=\\mathcal{D}_y)} \\cdot \\frac{1}{|w|^N} C \\cdot \\mathcal{N}(z|\\mu,\\sigma^2) \\cdot \\frac{1}{C_z} \\\\\n&= \\mathcal{N}(z|\\mu, \\sigma^2)\n\\end{align}\n$$\n\n#### Calculating the Posterior Predictive Distribution (PPD)\n\nHaving found the posterior, we can determine the PPD:\n\n$$\np(y|\\mathcal{D}_y) = \\int p(y| z) p(z|\\mathcal{D}_y) dz\n$$\n\nTo calculate this, we will have to use the identity for a product of two Gaussians.\n\n$$\n\\begin{align}\np(y|\\mathcal{D}_y) &= \\int \\frac{1}{|w|} \\mathcal{N}\\left(z|\\frac{y-b}{w}, \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2\\right) \\mathcal{N}(z|\\mu, \\sigma^2) dz \\\\\n&= \\int \\frac{1}{|w|} C^* \\mathcal{N}\\left(z|\\mu^*, \\left(\\sigma^*\\right)^2\\right) dz \\\\\n\\end{align}\n$$\n\n#### Calculating the Posterior Predictive Distribution (PPD)\n\nWe can find these parameters from the identity for a product of two Gaussians.\n\n$$\np(y|\\mathcal{D}_y) = \\int \\frac{1}{|w|} C^* \\mathcal{N}\\left(z|\\mu^*, \\left(\\sigma^*\\right)^2\\right) dz\n$$\n\nwhere\n\n$\\mu^* = \\left(\\sigma^* \\right)^2 \\left( \\frac{\\mu}{\\sigma^2} + \\frac{(y-b)/w}{\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2} \\right) = \\left(\\sigma^* \\right)^2 \\left( \\frac{\\mu}{\\sigma^2} + \\frac{(y-b)\\cdot w}{\\sigma_{y|z}^2} \\right)$\n\n$\\left( \\sigma^* \\right)^2 = \\frac{1}{\\frac{1}{\\sigma^2}+\\frac{1}{\\left( \\frac{\\sigma_{y|z}}{w}\\right)^2}}= \\frac{1}{\\frac{1}{\\sigma^2}+\\frac{w^2}{\\sigma_{y|z}^2}}$\n\n$C^* = \\frac{1}{\\sqrt{2\\pi \\left( \\sigma^2 + \\frac{\\sigma_{y|z}^2}{w^2} \\right)}}\\exp\\left[ - \\frac{\\left(\\mu - \\frac{y-b}{w}\\right)^2}{2\\left( \\sigma^2+\\frac{\\sigma_{y|z}^2}{w^2}\\right)}\\right]$\n\n## Next class\n\nIn the next class we will finish this example, by solving this integral to determine the PPD $p(y|\\mathcal{D}_y)$.\n\n### See you next class\n\nHave fun!\n", "meta": {"hexsha": "3096a1f8ea971e9d1d2f986de71cf8c7acc6a115", "size": 195742, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture5/3dasm_Lecture5.ipynb", "max_stars_repo_name": "shushu-qin/3dasm_course", "max_stars_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-02-07T18:45:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T21:45:27.000Z", "max_issues_repo_path": "Lectures/Lecture5/3dasm_Lecture5.ipynb", "max_issues_repo_name": "shushu-qin/3dasm_course", "max_issues_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture5/3dasm_Lecture5.ipynb", "max_forks_repo_name": "shushu-qin/3dasm_course", "max_forks_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2022-02-07T18:45:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T19:30:17.000Z", "avg_line_length": 155.5977742448, "max_line_length": 150788, "alphanum_fraction": 0.8648271705, "converted": true, "num_tokens": 10621, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39606818053136394, "lm_q2_score": 0.3557749071749625, "lm_q1q2_score": 0.1409111201635023}}
{"text": "```python\n%run ../../common/import_all.py\n\nfrom common.setup_notebook import set_css_style, setup_matplotlib, config_ipython\nconfig_ipython()\nsetup_matplotlib()\nset_css_style()\n```\n\n\n\n\n\n\n\n\n\n\n# The $\\chi^2$ test\n\n## What is\n\nThe $\\chi^2$ test is a statistical hypothesis test in which the distribution of the test statistic calculated on the data is a [$\\chi^2$ distribution](../distributions-measures/famous-distributions.ipynb#Chi-squared,-$\\chi^2$) under null hypothesis. The assumption is that data is normally distributed and independent so the $\\chi^2$ test can also be used to reject the hypothesis that data are independent.\n\n\n\nIt is used with categorical data to see if the number of individuals in each category is consistent with the expected values. In practice, the test is used to determine if there is a significant difference between the expected frequencies and the observed frequencies of the outcomes of an experiment in one or more categories, that is, if the observed differences are due to chance. The idea is: is the number of individuals falling into each category significantly different from the number you would expect under the null hypothesis? Is this difference between expected and observed data due to sampling or is it real?\n\nThe $\\chi^2$ is defined as \n\n$$\n\\chi^2 = \\sum_i \\frac{(o_i - h_i)^2}{h_i} \\ ,\n$$\n\nwhere $o_i$ is the observed value and $h_i$ the null hypothesis value. \n\nThe computed $\\chi^2$ has to be compared to [table values](http://sites.stat.psu.edu/~mga/401/tables/Chi-square-table.pdf) for the $\\chi^2$ distribution at the chosen level of significance and for given degrees of freedom one has in order to decide if the null hypothesis can be rejected or not, using the [$p$-value](../concepts/p-value-confidence-level.ipynb).\n\n## An example\n\nThis simple example has been adapted from [[here]](#example-dice).\n\nLet's say that we have a (6-faces) dice and we want to know if it is fair, that is, if each of the faces is equiprobable or if there is any bias towards a face. We throw the dice 60 times: in the case of a fair dice we would have each face appearing 10 times (60/6 where 6 is the number of possible results). This will be the null hypothesis.\n\nWe build a table containing the actual counts we get for each face, and said null hypothesis: \n\n| | | | | | | |\n| :--- |:---:|:---:|:---:|:---:|:---:|:---:|\n| | **Face 1** | **Face 2** | **Face 3** | **Face 4** | **Face 5** | **Face 6** | \n| **Observations** | 5 | 8 | 9 | 8 | 10 | 20 |\n| **Null Hypothesis** | 10 | 10 | 10 | 10 | 10 | 10 |\n\n\nThe $\\chi^2$ gets calculated as\n\n\\begin{align}\n\\chi^2 = \\frac{(5-10)^2}{10} + \\frac{(8-10)^2}{10} + \\frac{(9-10)^2}{10} &+& \\\\ \n\\frac{(8-10)^2}{10} + \\frac{(10-10)^2}{10} + \\frac{(20-10)^2}{10} = 13.4\n\\end{align}\n\nThe number of degrees of freedom is the number of terms minus 1 , so $6-1=5$. Looking up for the values of the $\\chi^2$ distribution at this number of degrees of freedom and for a confidence level of $95\\%$ we get a value of $11.070$. Because our calculated $\\chi^2$ exceeds the table value, this means that the $p$-value associated to it is smaller than $0.05$, so we can discard the null hypothesis at that significance level. \n\nNevertheless, note that if we choose a confidence level of $99\\%$ instead, so want to be safer, we cannot discard the null hypothesis as the table value for the $\\chi^2$ at that level is $15.086$, bigger than our calculated one, hence the $p$-value does pass the required threshold of $0.01$. \n\n## A typical use case: the goodness of a distribution fit\n\nThe $\\chi^2$ test is widely used to determine how good a fit is, that is, how well a statistical model describes (fits) the observational points. The number of degrees of freedom to be used to retrieve the comparison with table values is the total number of observations minus the number of fit parameters. \n\n### Fitting a uniform distribution\n\nLet's say we have $n$ data points and we bin them into $b$ bins, the expected occurrence frequency of each bin (the number per bin expected) would be, given that the distribution is uniform,\n\n$$\nh_i = \\frac{n}{b} \\ \\ \\forall i \\ ,\n$$ \n\n$i$ being the index of the bins.\n\nOur $\\chi^2$ test statistic is\n\n$$\n\\chi^2 = \\sum_{i=1}^b \\frac{(o_i - h_i)^2}{h_i}\n$$\n\nwhere $o_i$ is the observed number of data points in the bin. \n\n\n### Fitting a non-uniform distribution\n\nIn that case the hypothesis values have to be computed from the hypothesis distribution.\n\n## References \n\n1. Code is hidden for ease of viewing. Click the Show/Hide button to see. \n
\n```\n\n\n\n\n Code is hidden for ease of viewing. Click the Show/Hide button to see. \n
\n\n\n\n\n```python\nfrom IPython.display import display, Math, Latex, HTML\nimport ipywidgets as widgets\n```\n\n\n```python\ntry:\n from geogebra.ggb import *\nexcept ImportError:\n !pip install --upgrade --force-reinstall --user git+git://github.com/callysto/nbplus.git#egg=geogebra\\&subdirectory=geogebra\n from importlib import reload\n import site\n reload(site)\n from geogebra.ggb import * \nggb = GGB().setDefaultOptions(enableShiftDragZoom=False)\n```\n\n\n
\n\n\n\n \n\n\n# Inductive Reasoning and Deductive Reasoning\n\nThere are two forms of reasoning that that are useful when investigating a piece of mathematics.\n\n* `Inductive reasoning` involves looking for **patterns** in evidence in order to come up with conjectures (i.e. things that are likely to be true). This sort of reasoning will **not** tell you whether or not something actually *is* true but it is still very useful for making connections and figuring out what to investigate next.\n\n* `Deductive reasoning` involves starting with what you **know** and logically figuring out if some conjecture **must** also be true (and why). While deductive reasoning is stronger than inductive reasoning, it can also be more difficult to use.\n\nIn practice, one will often use `inductive reasoning` to make conjectures and `deductive reasoning` to verify them. In some cases producing a conjecture will require a mix of inductive and deductive reasoning.\n\nIn this notebook we will go over some example problems to help illustrate how one would go about using `inductive` and `deductive` reasoning in problem solving while avoiding pitfalls. Being able to apply these skills will make you a more effective problem solver. Being able to distinguish between the two will help you maintain a clear understanding of what you're doing, why you're doing it, and avoid mistakes in the process.\n\n## A Flawed Application of Inductive Reasoning\n\nConsider a circle. Suppose we were to add a certain number of dots to the edge of the circle and then draw chords connecting every pair of dots. The chords would partition the circle into a certain number of regions. *Can we find a relationship between the number of dots and the number of regions?* For instance, a circle with a two dots along the edge has one chord connecting them and is partitioned into two regions but a circle with three dots along the edge has three chords and is partitioned into four regions.\n\nHere is a simple applet to help visualize the problem. The slider at the bottom controls the number of dots along the edge (from $1$ to $6$). I've labeled each region with a number to make them easier to count.\n\n\n```python\n%%html\n\n```\n\n\n\n\n\n\nIf we look at the number of regions in the first five examples\n\n| dots | regions |\n| ---- | ------- |\n| 1 | 1 |\n| 2 | 2 |\n| 3 | 4 |\n| 4 | 8 |\n| 5 | 16 |\n\nand apply inductive reasoning then we may convince ourselves that the circle with $n$ dots will have $2^{n-1}$ regions.\n\n**Is that true?** *Note: If our inductive reasoning is correct then the sixth case will have $2^{6-1}=32$ regions.*\n\nUnfortunately, as it turns out the sixth circle will break down into $31$ regions, not $32$ regions. This is an example where inductive reasoning can lead you astray. Fortunately for us we managed to find a counterexample right away but there are conjectures where the first counterexample took decades to find and required numbers so large that it's virtually impossible for people to find them by hand. So we should always be very skeptical about the things inductive thinking may lead us to believe.\n\n## Some Flawed Applications of Deductive Reasoning\n\nDeductive reasoning can also fail us if we are not careful. It is possible to get caught up manipulating equations and not realize there's an underlying logical problem.\n\nHere are two flawed proofs. Try and find the problem in each one!\n\n### A Classic Flawed Proof\n\nThere are a few variations of this proof (with the same flaw) floating around. Every so often a student rediscovers it and thinks they've broken math.\n\nLet $a=b$.\n\nThen it follows that $b^2=ab$.\n\n\n$$\n\\begin{align*}\n a^2 - b^2 &= a^2 - b^2\\\\\n a^2 - b^2 &= a^2 - ab \\tag{Since $b^2=ab$}\\\\\n (a+b)(a-b) &= (a)(a-b) \\tag{Factoring}\\\\\n a+b &= a \\tag{Divide by sides by $a-b$}\\\\\n 2a &= a \\tag{Since $a=b$}\\\\\n 2 &= 1 \\tag{Divide both sides by $a$}\n\\end{align*}\n$$\n\n\nHint: The problem involves division.\n\nThe problem is introduced when both sides are divided by $a-b$ because $a-b=0$ and division by zero is not allowed (for reasons like this).\n\n### A Flawed Proof Involving Radicals\n\nThis one is somewhat less common but still interesting.\n\n\n$$\n\\begin{align*}\n -1 \n &= i^2 \\\\\n &= (i)(i) \\\\\n &= \\sqrt{-1}\\sqrt{-1} \\\\\n &= \\sqrt{(-1)(-1)} \\\\\n &= \\sqrt{1} \\\\\n &= 1\n\\end{align*}\n$$\n\n\nSo $-1=1$.\n\nHint: The problem involves distributing roots.\n\nThe problem occurs because $\\sqrt{ab}=\\sqrt{a}\\sqrt{b}$ only holds when $a$ and $b$ are both greater than or equal to $0$ (neither $a$ nor $b$ are allowed to be negative).\n\n## Some Applications of Inductive Reasoning\n\n### Sum of the first n odd integers\n\nSuppose you need to compute the sum of the first $100$ odd integers. You could do this directly but that likely wouldn't be very fun or interesting. Let's instead try applying inductive reasoning to try to come up with a better way to do it.\n\nBefore we can start looking for patterns we'll first need to generate some examples (so that we can use them as evidence later). Let's do that in Python:\n\n\n```python\n# Create a list of odd integers from 1 to 20 (incrementing by 2 each time).\noddIntegers = range(1,20,2)\n\n# Print a nice heading.\nprint('| n | Odd | S(n)|')\nprint('------------------')\n\n# For each odd integer print the step, the integer, and the sum of all odd integers so far.\nstep = 0\noddSum = 0\nfor odd in oddIntegers:\n step = step + 1\n oddSum = oddSum + odd\n print('|{:3d} | {:3d} | {:3d} |'.format(step, odd, oddSum))\n```\n\n | n | Odd | S(n)|\n ------------------\n | 1 | 1 | 1 |\n | 2 | 3 | 4 |\n | 3 | 5 | 9 |\n | 4 | 7 | 16 |\n | 5 | 9 | 25 |\n | 6 | 11 | 36 |\n | 7 | 13 | 49 |\n | 8 | 15 | 64 |\n | 9 | 17 | 81 |\n | 10 | 19 | 100 |\n\n\nFor brevity we'll use $S(n)$ to refer to the __sum of the first $n$ odd integers__.\n\nThe code above gives us a list of the first $10$ odd integers as well as $S(n)$ for each one (eg. for $n=3$, the $3$rd odd is $5$ and $S(3) = 1 + 3 + 5 = 9$).\n\nNow look closely at the data and try to see if there is a pattern there. Maybe consider changing the 20 in `range(1,20,2)` to a larger value to obtain more examples.\n\nHint: $1+3+5=3^2$.\n\nA good conjecture might be that\n\n$$S(n)=n^2.$$\n\nHere is a slider that tests our conjecture against a larger range of values:\n\n\n```python\nnum = widgets.IntSlider(description='n:', min=1)\ndef oddCompare(num):\n oddIntegers = range(1, num*2, 2)\n oddSum = sum(list(oddIntegers))\n print('S(n): {}'.format(oddSum))\n print('n^2: {}'.format((num*num)))\n\nout = widgets.interactive_output(oddCompare, {'num': num})\nwidgets.VBox([num, out])\n```\n\n\n VBox(children=(IntSlider(value=1, description='n:', min=1), Output()))\n\n\nNow that we have a conjecture it is typically very helpful if we're able to take it further and come up with some guesses about __why__ the conjecture holds. In this case the trick is to realize that we can compute the sum of the first $n$ odd integers by taking the sum of the first $n-1$ odd integers and adding the $n$'th odd. In other words:\n\n$$S(n+1)=S(n) + (n+1)^{\\text{th}} \\text{ odd integer}.$$\n\nFor instance, $S(5) = 1 + 3 + 5 + 7 + 9 = S(4) + 9$.\n\nThen combining this insight with the fact that we can represent square integers as squares yields this visualization:\n\n\nhttps://www.quora.com/What-is-the-sum-of-1+3+5+7+9+11+13+15+17+19+21+23+25+27+29+31+-+95+97+99 \n\nUnfortunately as convincing as this visual representation may be, it isn't strong enough to prove that $S(n)=n^2$ holds for all integers $n$. In order to prove that it holds for all $n$ we require a more advanced proof technique that we don't currently have access to. So we must grit our teeth and accept the fact that _as far as we know_ there could exist some integer out there for which this fails. Despite this some people will accept the visual argument as a proof because it provides the key intuition necessary to develop a proof.\n\n### Triangular numbers\n\nThere is famous story about the mathematician Carl Friedrich Gauss who as a child in primary school was tasked with computing the sum of the first 100 integers as a way to keep him busy. As the story goes, Gauss quickly realized a pattern and wrote down the answer of 5050 within a few seconds.\n\nFor brevity we'll use $T(n)$ to refer to the __sum of the first $n$ integers__.\n\nThe trick to seeing the pattern in this problem isn't as straightforward as the last one. As before we'll need to generate some examples to analyze first.\n\n\n```python\n# Create a list of the first 10 integers.\nintegers = range(1,11)\n\n# Print a nice heading.\nprint('| n | T(n)|')\nprint('-------------')\n\n# For each integer print the integer and the sum of all integer so far.\ntSum = 0\nfor num in integers:\n tSum = tSum + num\n print('| {:3d} | {:3d} |'.format(num, tSum))\n```\n\n | n | T(n)|\n -------------\n | 1 | 1 |\n | 2 | 3 |\n | 3 | 6 |\n | 4 | 10 |\n | 5 | 15 |\n | 6 | 21 |\n | 7 | 28 |\n | 8 | 36 |\n | 9 | 45 |\n | 10 | 55 |\n\n\nUnfortunately this didn't turn out to be very insightful.\n\nAnother approach we can take is to try to represent the sum differently. Taking a cue from the previous section we'll draw the sum visually:\n\n\n\nhttps://www.chegg.com/homework-help/use-ideas-behind-drawings-b-find-solution-gauss-s-problem-ex-chapter-1.1-problem-2a-solution-9780321987297-exc \n\n\nIt is because of this representation that the sum of the first $n$ integers is often referred to as a $n$'th `triangle number`. The value of our sum is represented by the 'area' of its triangular representation. Now, while it may not be easy to compute the area of such a triangle it is easy to compute the area of a rectangle and we can produce one by setting two triangles face to face:\n\n\nhttps://www.chegg.com/homework-help/use-ideas-behind-drawings-b-find-solution-gauss-s-problem-ex-chapter-1.1-problem-2a-solution-9780321987297-exc \n\nThis representation suggests a good conjecture for computing the $n$'th triangle number:\n$$T(n)=\\frac{(n)(n+1)}{2}.$$\n\nUnfortunately we once again lack the advanced proof technique we need to prove (using deductive thinking) that this is true for all integers $n$. So like before we've managed to obtain a really good conjecture through inductive thinking but are not able to confirm with certainty whether or not it's true. Like the previous example, some people may accept this visual argument as a proof.\n\n### One Weird Trick\n\nFrom time to time neat computational tricks like this will go viral on social media. Unfortunately the people presenting them will typically only show a few flashy examples and leave the readers feeling completely mystified about __why__ the trick works (or worse, feeling betrayed when it fails).\n\n\nhttps://brightside.me/article/nine-simple-math-tricks-youll-wish-you-had-always-known-92805/ \n\nBefore we start lets first rephrase what the picture is saying:\n\nTo compute $(97)(96)$:\n1. For each of our values, compute their difference from $100$:\n - $3=100-97$\n - $4=100-96$\n2. Multiply the differences to compute the first two digits of the result:\n - $12=(3)(4)$\n3. Add the differences and subtract the result from $100$ to compute the remaining digits of the result:\n - $93=100-(3+4)$\n4. Glue the two results together to get the final result:\n - $(97)(96)=9312$\n\nIt looks like step 3 could be simplified a bit to $93 = 97 - 4$ or $93 = 96 - 3$\n\nIn general it looks like the algorithm may be something like this:\n\nTo compute $(a)(b)$:\n1. For each of our values, compute their difference from $100$:\n - $a'=100-a$\n - $b'=100-b$\n2. Multiply the differences to compute the last two digits of the result:\n - $D=(a')(b')$\n3. Add the differences and subtract the result from $100$ to compute the remaining digits of the result:\n - $C=a-b'$\n4. Glue the two results together to get the final result:\n - $(a)(b)=C\\text{ appended with }D$\n\nNext lets have the computer generate some more examples for us so that we can get a better sense of the problem through `inductive reasoning`. The two sliders below let us choose some inputs and present the result created by the algorithm as well as the actual result with a message saying `Success!` if the algorithm gave the correct answer and `Fail!` if it gave the incorrect answer.\n\n\n```python\na = widgets.IntSlider(description='a:', min=85, max=115, value=100)\nb = widgets.IntSlider(description='b:', min=85, max=115, value=100)\n\ndef multiply(a,b):\n aDiff = 100-a\n bDiff = 100-b\n \n firstTwo = aDiff*bDiff\n lastTwo = a - bDiff\n \n result = str(lastTwo).lstrip('0') + str(firstTwo).zfill(2)\n print('Result: {}'.format(result))\n print('Actual product: {}'.format((a*b)))\n if (result == str(a*b)):\n print('Success!')\n else:\n print('Fail!')\n\nout = widgets.interactive_output(multiply, {'a': a, 'b':b})\nwidgets.VBox([a,b, out])\n```\n\n\n VBox(children=(IntSlider(value=100, description='a:', max=115, min=85), IntSlider(value=100, description='b:',…\n\n\nPlaying around with the sliders it seems that the algorithm fails in two cases:\n1. Where the first digits in the result are greater than $100$.\n * for instance, for $(101)(99)$ it gives `100-1` instead of `9999`\n2. Where the first digits in the result are negative.\n * For instance, for $(110)(110)$ it gives `120120` instead of `12100`\n\nCan you see a pattern in the way the numbers fail, maybe a way to fix it?\n\nIt seems like both instances can be fixed by carrying values. Perhaps, instead of gluing values together like strings we're actually supposed to be multiplying the last digits by $100$ and adding the first digits! For instance, instead of saying $$9312 = 93\\text{ appended with }12$$ we would say $$9312=(93)(100)+12.$$\n\nLets update the algorithm with this change:\n\nTo compute $(a)(b)$:\n1. For each of our values, compute their difference from $100$:\n - $a'=100-a$\n - $b'=100-b$\n2. Multiply the differences to compute the first two digits of the result:\n - $D=(a')(b')$\n3. Add the differences and subtract the result from $100$ to compute the remaining digits of the result:\n - $C=a - b'$\n4. Combine the two results together to get the final result:\n - $(a)(b)=(C)(100) + D$\n\nIn other words: $$ab = [a-(100-b)](100) + (100-b)(100-a).$$\n\nNext let's create a new version of the sliders:\n\n\n```python\na = widgets.IntSlider(description='a:', min=85, max=115, value=100)\nb = widgets.IntSlider(description='b:', min=85, max=115, value=100)\n\ndef multiply(a,b):\n aDiff = 100-a\n bDiff = 100-b\n \n firstTwo = aDiff*bDiff\n lastTwo = 100 - (aDiff + bDiff)\n \n result = lastTwo*100 + firstTwo\n print('Result: {}'.format(result))\n print('Actual product: {}'.format((a*b)))\n if (result == a*b):\n print('Success!')\n else:\n print('Fail!')\n\nout = widgets.interactive_output(multiply, {'a': a, 'b':b})\nwidgets.VBox([a,b, out])\n```\n\n\n VBox(children=(IntSlider(value=100, description='a:', max=115, min=85), IntSlider(value=100, description='b:',…\n\n\nFor the two failing examples mentioned above we now get:\n* For $(101)(99)$ we get `9999` which is correct!\n* For $(110)(110)$ we get `12100` which is correct!\n\nNow that we have a conjecture let's getting a better sense of why it works. One thing we can do is to take our equation from above:\n\n$$\n\\begin{align}\nab &= [a-(100-b)](100) + (100-b)(100-a) \\\\\n&= (a)(100) - (100-b)(100) + (100-b)(100-a)\n\\end{align}\n$$\n\nWe can visualize this:\n\n\n```python\n%%html\n\n```\n\n\n\n\n\n\nNote: This visualization assumes that $a$ and $b$ are between $0$ and $100$ (though in our conjecture we also allow them be greater than $100$).\n\nIn general these sorts of techniques where one performs a computation by manipulating the digits of a value is called an 'algorism' (not to be confused with algorithm). They're not really used very much these days (except for fast mental math gimmicks).\n\nThis particular algorism has a lot of generalizations for dealing with larger numbers but the reasoning behind them gets quite convoluted and in the end the most important part isn't proving that a algorism works for all numbers but that it works for all the numbers for which a mental computation is fast. In this case we can be satisfied by saying that this algorism works for numbers between $91$ and $109$ since those values are the easiest to use in practice.\n\n## Some Applications of Deductive Reasoning\n\n### Fractions\n\nFractions can be difficult to manipulate. Perhaps we can use deductive reasoning to come up with some easier ways to manipulate them.\n\nFirst some observations:\n1. Any integer, like $3$, can be written in fraction form: \n\n$$ \n3=\\frac{3}{1}. \n$$\n\n2. Any integer except $0$, like $3$, can be put into a fraction to get $1$: \n\n$$ \n1=\\frac{3}{3}. \n$$\n\n3. In order to multiply two fractions, such as $\\frac{2}{3}$ and $\\frac{5}{7}$, just multiply the numerators and denominators: \n\n$$ \n\\left( \\frac{2}{3}\\right) \\left( \\frac{5}{7} \\right) = \\frac{(2)(5)}{(3)(7)} = \\frac{10}{21}. \n$$\n\nThe first thing to note is that observation (3) gives us a way to factor any fraction: \n\n$$ \n\\frac{2}{3} = \\left( \\frac{2}{1}\\right) \\left( \\frac{1}{3} \\right). \n$$\n\nReducing a fraction, such as $\\frac{10}{15}$ to $\\frac{2}{3}$, can be achieved by applying observations (2) and (3) in reverse: \n\n$$\n\\frac{10}{15}=\\frac{(2)(5)}{(3)(5)}=\\left(\\frac{2}{3}\\right)\\left(\\frac{5}{5}\\right)=\\left(\\frac{2}{3}\\right)(1)=\\frac{2}{3}\n$$\n\nThe usual process of cancelling a denominator, like $(3) \\left(\\frac{2}{3}\\right)=2$ follows from these observations as well: \n\n$$ \n(3) \\left(\\frac{2}{3}\\right) = \\left(\\frac{3}{1}\\right) \\left(\\frac{2}{1}\\right)\\left(\\frac{1}{3}\\right) = \\left(\\frac{3}{3}\\right) \\left(\\frac{2}{1}\\right) = (1)(2) = 2\n$$\n\nLet's use these observations to manipulate some more complicated fractions.\n\n$$\n\\begin{align*}\n \\frac{2}{\\frac{1}{5}}\n & = \\left( \\frac{2}{\\frac{1}{5}}\\right) (1) \\tag{Multiply by $1$}\\\\\n & = \\left( \\frac{2}{\\frac{1}{5}}\\right) \\left(\\frac{5}{5} \\right) \\tag{By observation 2}\\\\\n & = \\frac{(2)(5)}{\\left( \\frac{1}{5}\\right) (5)} \\tag{By observation 3}\\\\\n & = \\frac{(2)(5)}{1} \\tag{By cancelling}\\\\\n & = (2)(5) \\tag{By observation 1}\\\\\n & = 10\n\\end{align*}\n$$\n\nAnother more complicated example:\n\n$$\n\\begin{align*}\n \\frac{\\frac{2}{3}}{\\frac{7}{5}}\n & = \\left( \\frac{\\frac{2}{3}}{\\frac{7}{5}} \\right) (1)(1) \\tag{Multiply by $1$}\\\\\n & = \\left( \\frac{\\frac{2}{3}}{\\frac{7}{5}} \\right) \\left(\\frac{3}{3} \\right)\\left(\\frac{5}{5} \\right) \\tag{By observation 2}\\\\\n & = \\frac{\\left( \\frac{2}{3} \\right) (3)(5)}{\\left(\\frac{7}{5} \\right) (3)(5)} \\tag{By observation 3}\\\\\n & = \\frac{(2)(5)}{(7)(3)} \\tag{By cancelling}\\\\\n & = \\frac{10}{21}\n\\end{align*}\n$$\n\nWe can manipulate even the most complicated fractions by __cleverly multiplying by 1__ in this way.\n\n### Distributive Property\n\nThe distributive property is extremely useful in simplifying expressions and performing computations. In fact, every multiplication algorithm you encounter will at some level boil down to some clever application of the distributive property. Simply put the distributive property tells us how addition and multiplication interact: \n\n$$\n(a+b)c = ac + bc.\n$$\n\nSince multiplication is commutative this statement is equivalent: \n\n$$\na(c+d) = ac + ad.\n$$\n\nThe FOIL mnemonic is just a special case of the distributive property:\n\n$$ \n(a+b)(c+d) = (a+b)c + (a+b)d = ac + bc + ad + bd. \n$$\n\nIt is important to remember that the distributive property can be read two ways. In one sense it tells us how to distribute multiplication across addition but in another sense it tells us how to undo that distribution.\n\nFor an example, suppose you have something like \n\n$$\n6x + 10xy.\n$$\n\nIf we notice that both $6x$ and $10xy$ have $2x$ as a factor, since $6x=2x(3)$ and $10xy=2x(5y)$, then we can rewrite that as \n\n$$\n6x + 10xy = 2x(3 + 5y).\n$$\n\nThis technique is an extremely useful application of deductive reasoning. *Do not underestimate it.*\n\n### Mentally Computing Simple Percentages\n\nThere are many occasions where one might be asked to compute a percentage of some value on the spot (eg. tipping at a restaurant). Fortunately there's a trick to doing it quickly.\n\nFirst notice that computing $10\\%$ is as easy as moving the decimal point one digit to the left (eg. $10\\%$ of $25.3$ is $2.53$). Similarly, $1\\%$ can be computed by moving the decimal point two digits to the left.\n\nFrom there on it's just a matter of adding, subtracting, and/or multiplying these percentages to get to the desired percentage. For instance, $18\\%$ can be computed by first computing $10\\%$, doubling the value to get $20\\%$, moving the decimal over one more time to get $2\\%$ and then subtracting the $2\\%$ value from the $20\\%$ value. It's easier than it sounds.\n\nThis is an application of deductive reasoning because we reached all of the assertions here logically, not by looking at any patterns and conjecturing.\n\n[](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)\n", "meta": {"hexsha": "ba0393dd436ae342cf0ee4c133422b34f7b245aa", "size": 38394, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/InductiveAndDeductiveReasoning/inductive-and-deductive-reasoning.ipynb", "max_stars_repo_name": "BryceHaley/curriculum-jbook", "max_stars_repo_head_hexsha": "d1246799ddfe62b0cf5c389394a18c2904383437", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-03-18T18:19:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T18:19:40.000Z", "max_issues_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/InductiveAndDeductiveReasoning/inductive-and-deductive-reasoning.ipynb", "max_issues_repo_name": "callysto/curriculum-jbook", "max_issues_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_build/jupyter_execute/curriculum-notebooks/Mathematics/InductiveAndDeductiveReasoning/inductive-and-deductive-reasoning.ipynb", "max_forks_repo_name": "callysto/curriculum-jbook", "max_forks_repo_head_hexsha": "ffb685901e266b0ae91d1250bf63e05a87c456d9", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.1376146789, "max_line_length": 544, "alphanum_fraction": 0.5570401625, "converted": true, "num_tokens": 6237, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38861804086755836, "lm_q2_score": 0.35936415888237616, "lm_q1q2_score": 0.139655395382887}}
{"text": "Métodos Numéricos \nCapítulo 4: Interpolación Numérica \n2021/02 \nMEDELLÍN - COLOMBIA \n\n\n \n Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao \n
\n\n*** \n\n***Docente:*** Carlos Alberto Álvarez Henao, I.C. D.Sc.\n\n***e-mail:*** carlosalvarezh@gmail.com\n\n***skype:*** carlos.alberto.alvarez.henao\n\n***Linkedin:*** https://www.linkedin.com/in/carlosalvarez5/\n\n***github:*** https://github.com/carlosalvarezh/Metodos_Numericos\n\n***Herramienta:*** [Jupyter](http://jupyter.org/)\n\n***Kernel:*** Python 3.8\n\n\n***\n\nTabla de Contenidos \n\n\n## Introducción\n\nLa información (datos) resultante de la medición de un evento ya sea natural o social viene dada en forma discreta o tabular, es decir, se expresa como un conjunto de pares ordenados $(x_i,y_i)$. Por ejemplo, los datos obtenidos de los censos poblacionales realizados en Colombia desde 1985 según el [DANE](https://www.dane.gov.co/) son:\n\n|Año|Población*|\n|:----:|:----:|\n|1985|30802|\n|1990|34130|\n|1995|37472|\n|2000|40296|\n|2005|42889|\n|2010|45510|\n|2015|48203|\n\n(\\* en miles de habitantes)\n\n***Nota:*** Ejemplo tomado de las notas de clase del curso Simulación Computacional de la Universidad EAFIT y es autoría del profesor Nicolás Guarín.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.interpolate\nfrom scipy.optimize import curve_fit\n\n```\n\n\n```python\nstart = 1985.\nstop = 2015.\nstep = int((stop - start) / 5) + 1\n\nx = np.linspace(start, stop, step)\ny = [30802, 34130, 37472, 40296, 42889, 45510, 48203]\n\nplt.plot(x,y, 'o')\nplt.grid(True)\n```\n\nSi quisieramos responder a la pregunta: ¿Cuál era la población de Colombia en el 2012? \n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, y, 'o')\nax.vlines(x=2012, ymin=30000.0, ymax=48203.0, color='r')\nax.hlines(y=46000.0, xmin=1985.0, xmax=2012.0, color='y')\nax.hlines(y=47000.0, xmin=1985.0, xmax=2012.0, color='b')\nax.hlines(y=48000.0, xmin=1985.0, xmax=2012.0, color='g')\nplt.grid(True)\nplt.show()\n```\n\n¿cuál de los valores mostrados arriba es el más correcto? Podemos plantear varias ideas para determinar dicho valor:\n\n- Considerando que la función es constante entre los valores\n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, y, 'o')\n\nax.hlines(y=y[0], xmin=x[0], xmax=x[0] + 2, color='b')\nax.vlines(x=x[0] + 2, ymin=y[0], ymax=y[1], color='b')\n\nfor i in range(1, len(x)-1):\n ax.hlines(y=y[i], xmin=x[i]-3, xmax= x[i] + 2, color='b')\n ax.vlines(x=x[i]+2, ymin=y[i], ymax=y[i+1], color='b')\n\nax.hlines(y=y[-1], xmin=x[-1]-3, xmax=x[-1]+2, color='b')\n\nax.vlines(x = 2012, ymin = 30000.0, ymax = y[-1], color = 'r')\nax.hlines(y = y[-1], xmin = 1985.0, xmax = 2012.0, color = 'r')\n\nplt.grid(True)\nplt.show()\n```\n\n- Asumiendo que la función es lineal entre valores \n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, y, 'o--')\nax.vlines(x = 2012, ymin = 30000.0, ymax = 46700, color = 'r')\nax.hlines(y = 46700, xmin = 1985.0, xmax = 2012.0, color = 'r')\n\nplt.grid(True)\nplt.show()\n```\n\n- Determinando un polinomio que pase por cada uno de los puntos.\n\n\n```python\nfig, ax = plt.subplots()\n\nax.plot(x, y, 'o')\n\nt = np.linspace(0, 1, len(x)) # parameter t to parametrize x and y\npxLagrange = scipy.interpolate.lagrange(t, x) # X(T)\npyLagrange = scipy.interpolate.lagrange(t, y) # Y(T)\nn = 100\nts = np.linspace(t[0],t[-1],n)\nxLagrange = pxLagrange(ts) # lagrange x coordinates\nyLagrange = pyLagrange(ts) # lagrange y coordinates\nax.plot(xLagrange, yLagrange,'b-')\n\nax.vlines(x=2012, ymin=30000.0, ymax=46700, color='r')\nax.hlines(y=46700, xmin=1985.0, xmax=2012.0, color='r')\n\nax.grid(True)\nplt.show()\n```\n\n- ajustando la curva que mejor se aproxime a cada uno de los datos. En este ejemplo haremos un ajuste lineal, pero no es la única forma de hacerlo.\n\n\n```python\n# define the true objective function\ndef objective(x, a, b):\n return a * x + b\n \n# curve fit\npopt, _ = curve_fit(objective, x, y)\n\n# summarize the parameter values\na, b = popt\nprint('y = %.5f * x + %.5f' % (a, b))\n\nfig, ax = plt.subplots()\n\n# plot input vs output\nax.scatter(x, y)\n\n# define a sequence of inputs between the smallest and largest known inputs\nx_line = np.arange(min(x), max(x), 1)\n\n# calculate the output for the range\ny_line = objective(x_line, a, b)\n\n# create a line plot for the mapping function\nax.plot(x_line, y_line, '--', color='b')\n\nyfit = a * 2012 + b\n\nax.vlines(x=2012, ymin=30000.0, ymax=yfit, color='r')\nax.hlines(y=yfit, xmin=1985.0, xmax=2012.0, color='r')\n\nplt.grid(True)\nplt.show()\n```\n\nEn este curso nos centraremos en los esquemas de interpolación, por lo que los esquemas de ajuste no se tratarán.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Propósitos de la interpolación\n\nLos problemas de interpolación surgen de muchas fuentes diferentes y pueden tener muchos propósitos diferentes. Algunos de estos incluyen:\n\n- Trazar una curva suave a través de puntos de datos discretos\n\n\n- Evaluación rápida y sencilla de una función matemática\n\n\n- Reemplazar una función difícil por una fácil\n\n\n- Diferenciar o integrar datos tabulares\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Diferencias entre Interpolación, Aproximación y Ajuste de curvas\n\nLas técnicas para resolver el problema de determinar un valor intermedio entre dos valores conocidos se pueden enmarcar en:\n\n- [Interpolación](https://en.wikipedia.org/wiki/Interpolation)\n\n\n- [Aproximación](https://en.wikipedia.org/wiki/Approximation_theory)\n\n\n- [Ajuste de curvas](https://en.wikipedia.org/wiki/Curve_fitting)\n\nA continuación vamos a describir brevemente las diferencias entre ellas.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Interpolación vs Aproximacion\n\nEn interpolación, se ajustan todos los puntos de datos de forma exacta mientras que la aproximación, como su nombre indica, solo se aproxima.\n\nCuando se trata de la idoneidad, la interpolación es apropiada para suavizar esos datos ruidosos y no es apropiada cuando los puntos de datos están sujetos a errores experimentales u otras fuentes de error significativo. Tener un gran conjunto de puntos de datos también puede sobrecargar la interpolación. Por otro lado, la aproximación es principalmente apropiada para el diseño de rutinas de biblioteca para calcular funciones especiales. Esto se debe a la naturaleza de estas funciones: se considera que los valores exactos no son esenciales y, hasta cierto punto, ineficaces cuando los valores aproximados funcionan.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Interpolación vs Ajuste de curvas\n\nEn el ajuste de curvas, no ajustamos todos nuestros puntos de datos. Por eso tenemos el concepto de residuos. En la interpolación, se obliga a la función a ajustarse a todos los puntos de datos. Ver la referencia del [Cuarteto de ascombe](https://es.wikipedia.org/wiki/Cuarteto_de_Anscombe) como un contra ejemplo de los inconvenientes en los ajustes de curvas.\n\nAhora que sabemos de qué categoría estamos hablando, reduzcamos a las familias de funciones utilizadas para la interpolación.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Elección de la función de interpolación\n\nEs importante darse cuenta de que existe cierta arbitrariedad en la mayoría de los problemas de interpolación. Hay arbitrariamente muchas funciones que interpolan un conjunto dado de datos. Simplemente requiriendo que alguna función matemática se ajuste a los puntos de datos deje exactamente abiertos tales\npreguntas como:\n\n- ¿Qué forma debe tener la función? Puede haber consideraciones matemáticas o físicas relevantes que sugieran una forma particular de interpolante.\n\n\n- ¿Cómo debería comportarse la función entre puntos de datos?\n\n\n- ¿Debería la función heredar propiedades de los datos, como monotonicidad, convexidad o periodicidad?\n\n\n- Si se grafican la función y los datos, ¿los resultados deberían ser agradables a la vista?\n\n\n- ¿Estamos interesados principalmente en los valores de los parámetros que definen la función de interpolación, o simplemente en evaluar la función en varios puntos para graficar u otros propósitos?\n\n\nLa elección de la función de interpolación depende de las respuestas a estas preguntas, así como de los datos que se deben ajustar y generalmente se basa en:\n\n- Qué tan fácil es trabajar con la función (determinar sus parámetros a partir de los datos, evaluar la función en un punto dado, diferenciar o integrar la función, etc.)\n\n\n- Qué tan bien las propiedades de la función coinciden con las propiedades de los datos a ser t (suavidad, monotonicidad, convexidad, periodicidad, etc.)\n\n\nAlgunas familias de funciones que se utilizan comúnmente para la interpolación incluyen:\n\n\n- [Polinomios](https://en.wikipedia.org/wiki/Polynomial_interpolation)\n\n\n- [Interpolación a trazos](https://en.wikipedia.org/wiki/Spline_interpolation)\n\n\n- Funciones trigonométricas\n\n\n- Exponenciales\n\n\n- Funciones racionales\n\n\nEn este capítulo nos centraremos en la interpolación por polinomios e interpolación a trazos.\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n## Interpolación Polinomial\n\n### Introducción\n\nLa interpolación polinomial es el tipo de interpolación más simple y común. Una de sus características es que siempre hay un polinomio único de grado como máximo $n-1$ que pasa por $n$ puntos de datos.\nHay muchas formas de calcular o representar un polinomio, pero se reducen a la misma función matemática. Algunos de los métodos son la base monomial, la base de [Lagrange](https://en.wikipedia.org/wiki/Lagrange_polynomial) y la base de [Newton](https://en.wikipedia.org/wiki/Newton_polynomial). Como puede observar, reciben el nombre de su base.\n\n***Inconvenientes:***\n\n- ***Polinomio de alto grado:*** una elección adecuada de funciones de base y puntos de interpolación puede mitigar algunas de las dificultades asociadas con polinomio de alto grado.\n\n\n- ***Sobreajuste ([overfitting](https://en.wikipedia.org/wiki/Overfitting)):*** ajuste de un solo polinomio a una gran cantidad de puntos de datos, lo que probablemente produciría un comportamiento de oscilación insatisfactorio en el interpolante.\n\nLa fórmula general de un polinomio de $n$-ésimo orden es:\n\n\\begin{equation*}\nf_n(x) = a_0 + a_1x + a_2x^2 +…+ a_nx^n\n\\label{eq:Ec4_1} \\tag{4.1}\n\\end{equation*}\n\nEl polinomio de interpolación dado por la ecuación $\\eqref{eq:Ec4_1}$ consiste en determinar el único polinomio de n-ésimo orden que se ajusta a los $n+1$ puntos dados. Este polinomio proporciona una fórmula para calcular los valores intermedios.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Interpolación Lineal\n\nEl método más simple de interpolación es conectar dos puntos mediante una línea recta.\n\n\n \n
\n\n\n\nDe la figura se tiene:\n\n\\begin{equation*}\n\\frac{f_1(x)-f(x_0)}{x-x_0}=\\frac{f(x_1)-f(x_0)}{x_1-x_0}\n\\label{eq:Ec4_2} \\tag{4.2}\n\\end{equation*}\n\nreordenando,\n\n\\begin{equation*}\nf_1(x)=f(x_0)+\\frac{f(x_1)-f(x_0)}{x_1-x_0}(x-x_0)\n\\label{eq:Ec4_3} \\tag{4.3}\n\\end{equation*}\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n#### Ejemplo interpolación lineal\n\n- Estime el valor de $Ln(2)$ empleando la interpolación lineal, entre $x_0=0$ y $x_1=6$\n\nEvaluando el valor del logaritmo en cada uno de los dos puntos, $Ln(1)=0$ y $Ln(6)=1.791759$\n\n$$f_1(2)=0+\\frac{1.791759-0}{6-1}(2-1)=0.3583519$$\n\nEl valor exacto es $Ln(2)=0.693147$, que representa un error relativo porcentual de\n\n$$Er(\\%)=\\frac{|0.693147-0.3583519|}{0.693147}=48.3\\%$$\n\nSi se disminuye el valor del intervalo a evaluar, por ejemplo en $x_1=4$, se llega a \n\n$$f_1(2)=0+\\frac{1.386294-0}{4-1}(2-1)=0.462098$$\n\nobteniendo un error relativo porcentual del $33.3\\%$.\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n#### Visualización computacional\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nn = 20\n\nfig, ax = plt.subplots()\n\nx = np.linspace(1, 6, n)\ny = np.log(x)\n\nx1 = [x[0], x[-1]]\ny1 = [np.log(x[0]), np.log(x[-1])]\n\nx2 = [x[0], 4]\ny2 = [np.log(x[0]), np.log(4)]\n\nax.plot(x,y, '-', x1, y1, 'o-', x2,y2, 'o-')\nax.vlines(x = 2, ymin = 0.0, ymax = np.log(2), color = 'r', linestyles='dashed')\n\nplt.grid(True)\n\n```\n\nEl error en la interpolación lineal resulta de aproximar una curva con una línea recta.\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n#### Mejoras al esquema de interpolación lineal\n\n- Disminuir el tamaño del intervalo.\n\n\n- Introducir alguna curvatura en la línea que conecta los puntos.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n\n \n
\n\n\n\n\nLa forma general de una ecuación cuadrática puede expresarse de la siguiente forma:\n\n\\begin{equation*}\nf_2(x) = b_0 + b_1(x–x_0) + b_2(x–x_0)(x–x_1)\n\\label{eq:Ec4_4} \\tag{4.4}\n\\end{equation*}\n\nDebemos determinar los valores de los coeficientes $b_i$.\n\n- Para $b_0$, en la ecuación $\\eqref{eq:Ec4_4}$, con $x = x_0$:\n\n\\begin{equation*}\nb_0 = f(x_0)\n\\label{eq:Ec4_5} \\tag{4.5}\n\\end{equation*}\n\n- Para $b_1$, sustituyendo la ecuación $\\eqref{eq:Ec4_5}$ en la la ecuación $\\eqref{eq:Ec4_4}$, y evaluando en $x = x_1$:\n\n\\begin{equation*}\nb_1 = \\frac{f(x_1)-f(x_0)}{(x_1 - x_0)}\n\\label{eq:Ec4_6} \\tag{4.6}\n\\end{equation*}\n\n- Para $b_2$, las ecuaciones $\\eqref{eq:Ec4_5}$ y $\\eqref{eq:Ec4_6}$ pueden sustituirse en la ecuación $\\eqref{eq:Ec4_4}$, evaluada en $x_2$\n\n\\begin{equation*}\nb_2=\\frac{\\frac{f(x_2)-f(x_1)}{(x_2-x_1)}-\\frac{f(x_1)-f(x_0)}{(x_1-x_0)}}{(x_2 - x_0)}\n\\label{eq:Ec4_7} \\tag{4.7}\n\\end{equation*}\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n#### Ejemplo interpolación cuadrática\n\nContinuando con el ejemplo anterior, se van a considerar los siguientes puntos:\n\n$$x_0=1 \\hspace{1cm} f(x_0)=0.000000$$\n$$x_1=4 \\hspace{1cm} f(x_1)=1.386294$$\n$$x_2=6 \\hspace{1cm} f(x_2)=1.791759$$\n\nDe las ecuaciones anteriores, \n\n$$b_0=0$$\n\n$$b_1=\\frac{1.386294-0}{4-1}=0.4620981$$\n\n$$b_2=\\frac{\\frac{1.791759-1.386294}{6-4}-0.4620981}{6-1}=-0.0518731$$\n\nSustituyendo estos valores en la ecuación cuadrática inicial, se llega a:\n\n$$f_2(x)=0+0.4620981(x-1)-0.0518731(x-1)(x-4)$$\n\ny evaluando en $x=2$, se llega a\n\n$$f_2(2)=0.565844$$\n\nque representa un error relativo porcentual del $18.4\\%$\n\n[Volver a la Tabla de Contenido](#TOC)\n\n#### Implementación computacional\n\n\n```python\ndef difdiv2o(x, y, xm):\n b0 = y[0]\n b1 = (y[1] - b0) / (x[1] - x[0])\n b2 = ((y[2] - y[1]) / (x[2] - x[1]) - b1) / (x[2] - x[0])\n\n return b0 + b1 * (xm - x[0]) + b2 * (xm - x[0]) * (xm - x[1])\n```\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nn = 20\n\nfig, ax = plt.subplots()\n\nx = np.linspace(1, 6, n)\ny = np.log(x)\n\nx1 = [x[0], 4, x[-1]]\ny1 = [np.log(x[0]), np.log(x1[1]), np.log(x[-1])]\nym = difdiv2o(x1,y1,2)\n\nx1.insert(1, 2)\ny1.insert(1,ym)\n\nax.plot(x, y, '-', x1, y1, 'o-')\nax.vlines(x = 2, ymin = 0.0, ymax = np.log(2), color = 'r', linestyles='dashed')\n\nplt.grid(True)\n```\n\n### Polinomio de diferencias divididas de Newton\n\nLo anterior puede ser generalizado para ajustar un polinomio de $n$-ésimo orden a $n+1$ datos:\n\n\n \n
\n\n\n\n\\begin{equation*}\nf_n(x) = b_0+b_1(x–x_0)+\\ldots+b_n(x–x_0)(x–x_1)\\ldots(x – x_{n-1})\n\\label{eq:Ec4_8} \\tag{4.8}\n\\end{equation*}\n\nDe igual manera que para las interpolaciones lineal y cuadrática, se llega a:\n\t\n\\begin{equation*}\nf_n(x)=f(x_0)+(x–x_0)f[x_1,x_0]+(x–x_0)(x–x_1)f[x_2,x-,x_0]+\\ldots+(x–x_0)(x–x_1)\\ldots(x–x_{n-1})f[x_n, x_{n-1},\\ldots,x_2,x_1,x_0]\n\\label{eq:Ec4_9} \\tag{4.9}\n\\end{equation*}\n\nConocido como *Polinomio de interpolación por [diferencias divididas de Newton](https://en.wikipedia.org/wiki/Divided_differences)*. Las evaluaciones de las funciones puestas entre paréntesis son diferencias divididas finitas.\n \n- ***Primera diferencia dividida:***\n\n\\begin{equation*}\nf[x_i, x_j]=\\frac{f(x_i)-f(x_j)}{(x_i-x_j)}\n\\label{eq:Ec4_10} \\tag{4.10}\n\\end{equation*}\n\n- ***Segunda diferencia dividida:*** representa la diferencia de las dos primeras diferencias divididas\n\n\\begin{equation*}\nf[x_i, x_j,x_k]=\\frac{f[x_i,x_j]-f[x_j,x_k]}{(x_i-x_k)}\n\\label{eq:Ec4_11} \\tag{4.11}\n\\end{equation*}\n\n$$\\vdots$$\n\n- ***$n$-ésima diferencia dividida:*** representa la diferencia de las dos primeras diferencias divididas\n\\begin{equation*}\nf[x_n, x_{n-1},\\ldots, x_1,x_0]=\\frac{f[x_n,x_{n-1},\\ldots,x_1]-f[x_{n-1},x_{n-2},\\ldots,x_0]}{(x_n-x_0)}\n\\label{eq:Ec4_12} \\tag{4.12}\n\\end{equation*}\n\nEste proceso recursivo lo podemos visualizar de la siguiente manera:\n\n\n \n
\n\n\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n#### Implementación computacional\n\nEn la página 513 del libro de Chapra y Canale, Figura 18.7, se tiene un algoritmo en Fortran para la implementación del código de Diferencias Divididas tipo Newton. Se invita al estudiante a que lo estudie y codifique en el lenguaje de preferencia.\n\n\n```python\n# Escriba aquí su código\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Análisis de Error para la interpolación polinomial tipo Newton\n\nLa ecuación $\\eqref{eq:Ec4_9}$ es similar a la *serie de expansión de Taylor*. Se agregan términos en forma secuencial para capturar el comportamiento de alto orden de la función a analizar. Estos términos son diferencias divididas finitas y, así, representan aproximaciones de derivadas de orden mayor.\n\nEl error de truncamiento se expresa entonces como:\n\n\\begin{equation*}\nR_n=\\frac{f^{(n+1)}(\\xi)}{(n+1)!} \\left ( x_{i+1}-x_i\\right )^{n+1}\n\\label{eq:Ec4_13} \\tag{4.13}\n\\end{equation*}\n\nPara una interpolación de n-ésimo orden, una relación análoga para el error es\n\n\n \n
\n\n\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Trazadores lineales\n\nLa unión más simple entre dos puntos es una línea recta. Los trazadores de primer grado para un grupo de datos ordenados pueden definirse como un conjunto de funciones lineales:\n\n\\begin{equation*}\n\\begin{split}\nf(x) & = f(x_0) + m_0(x - x_0), \\quad x_0 \\le x \\le x_1 \\\\\nf(x) & = f(x_1) + m_1(x - x_1), \\quad x_1 \\le x \\le x_2 \\\\\nf(x) & = f(x_2) + m_2(x - x_2), \\quad x_2 \\le x \\le x_3 \\\\\n&\\vdots \\\\\nf(x) & = f(x_{n-1}) + m_{n-1}(x - x_{n-1}), \\quad x_{n-1} \\le x \\le x_n\n\\end{split}\n\\label{eq:Ec4_21} \\tag{4.21}\n\\end{equation*}\n\ndonde $m_i=\\frac{f(x_{i+1})-f(x_i)}{(x_{i+1}-x_i)}$ es la pendiente de la línea recta que une los puntos. La principal desventaja de los trazadores de primer grado es que no son suaves. En los puntos donde se encuentran dos trazadores, la pendiente cambia de forma abrupta. La primer derivada de la función es discontinua en esos puntos.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Trazadores cuadráticos\n\nPara asegurar que las derivadas $m$-ésimas sean continuas en los nodos, se debe emplear un trazador de un grado de, al menos, $m+1$. El objetivo de los trazadores cuadráticos es obtener un polinomio de segundo grado para cada intervalo entre los datos. De manera general, el polinomio en cada intervalo se representa como:\n\n\n \n
\n\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Trazadores cúbicos\n\nEl objetivo es obtener polinomios de tercer grado para cada intervalo entre los nodos:\n\n\n\\begin{equation*}\n\\begin{split}\nq_k(x_k)&=y_k \\\\\nq_k(x_{k+1})&=y_{k+1} \\quad k=0,1,2 \\ldots, n-1\n\\end{split}\n\\label{eq:Ec4_28} \\tag{4.28}\n\\end{equation*}\n\nDe la ecuación [(4.28)](#Ec4_28) se obtienen $2n$ condiciones. También, los polinomios $q_k(x)$ del interpolador cúbico $s(x)$ deben tener la misma pendiente y concavidad, es decir\n\n0\\}$$\nis called the cone of descent directions.\n\n**Definition:** The set $F\\cap D$ is called the cone of feasible descent directions.\n\n\n\n**(Obvious) Theorem:** Consider an optimization problem \n$$\n\\begin{align}\n\\min &\\ f(x)\\\\\n\\text{s.t. }&\\ x\\in S\n\\end{align}\n$$\nand let $x^*\\in S$. Now if $x^*$ is a local minimizer **then** the set of feasible descent directions $F\\cap D$ is empty.\n\n## Idea for the methods of feasible descent directions\n\n1. Find a feasible solution $x_0$ as the starting point ($k=0$).\n2. Find a feasible descent direction $d_k\\in D\\cap F$.\n3. Determine the step length ($\\alpha_k$) to the direction $d_k$ (Use line search to find an optimal step length).\n4. Update $x$ accordingly ($x_{k+1} = x_k + \\alpha_k d_k$).\n5. Check convegency. If not converged, set $k = k+1$ and go to 2.\n\n# Rosen's projected gradient method\n\nAssume a problem with linear equality constraints\n\n$$\n\\min f(x)\\\\\n\\text{s.t. } H(x)=Ax-b=0,\n$$\n\nwhere $A$ is a $l\\times n$ matrix ($l\\leq n$) and $b$ is a vector.\n\nLet $\\mathbf{x}$ be a feasible solution to the above problem.\n\nIt holds that:\n\n$$\n\\mathbf{Ax}=b \\\\\n\\rightarrow \\mathbf{A}(\\mathbf{x} + \\alpha \\mathbf{d}) = b \\\\\n\\rightarrow \\mathbf{Ax} + \\alpha \\mathbf{Ad} = b \\\\\n\\rightarrow b + \\alpha \\mathbf{Ad} = b\n$$\n\nThen, $\\mathbf{d}$ is a feasible direction *if and only if* $\\mathbf{Ad}=0$\n\nThus, the gradient $-\\nabla f(x)$ is a feasible descent direction, if \n\n$$ A\\nabla f(x)=0.$$\n\nThis may or may not be true (i.e. the gradient may or may not be a feasible descent direction).\n\nHowever, we can project the gradient to the set of feasible descent directions\n$$ \\{d\\in \\mathbb R^n: Ad=0\\},$$\nwhich now is a linear subspace.\n\n\n\n### Projection\n\nLet $a\\in \\mathbb R^n$ be a vector and let $L$ be a linear subspace of $\\mathbb R^n$. Now, the following are equivalent\n* $a^P$ is the projection of $a$ on $L$,\n* $\\{a^P\\} = \\operatorname{argmin}_{l\\in L}\\|a-l\\|$, and\n\n\n\n\n## Projected gradient\n\nThe projection of the gradient $\\nabla f(x)$ on the set $\\{d\\in \\mathbb R^n: Ad=0\\}$ is denoted by $\\nabla f(x)^P$ and called the *projected gradient*. \n\nNow, given some conditions, the projected gradient gives us a feasible descent direction.\n\n\n\n## How to compute the projected gradient?\n\nThere are different ways, but at this course we can use optimization. Basically, the optimization problem that we have to solve is\n$$\n\\min \\|\\nabla f(x)-d\\|\\\\\n\\text{s.t. }Ad=0.\n$$\n\nSince it is equivalent to minimize the square of the objective function $\\sum_{i=n}\\nabla_i f(x)^2+d_i^2-2\\nabla_i f(x)d_i$, we can see that the problem is a quadratic problem with equality constraints,\n$$\n\\min \\frac12 d^TId-\\nabla f(x)^Td\\\\\n\\text{s.t. }Ad=0\n$$\nwhich means that we just need to solve the system of equations (see e.g., https://en.wikipedia.org/wiki/Quadratic_programming#Equality_constraints)\n\n$$\n\\left[\n\\begin{array}{cc}\nI&A^T\\\\\nA&0\n\\end{array}\n\\right] \n\\left[\\begin{align}d\\\\\\lambda\\end{align}\\right]\n= \\left[ \n\\begin{array}{c}\n\\nabla f(x)\\\\\n0\n\\end{array}\n\\right],\n$$\n\nwhere $I$ is the identity matrix, and $\\lambda$ are the KKT multipliers.\n\n### Code in Python\n\n#### A function for projecting a vector to a linear space defined by $Ax=0$.\n\n\n```python\nimport numpy as np\n#help(np.linalg.solve)\n```\n\n\n```python\nimport numpy as np\ndef project_vector(A,vector):\n #convert A into a matrix\n A_matrix = np.matrix(A)\n #construct the \"first row\" of the matrix [[I,A^T],[A,0]]\n left_matrix_first_row = np.concatenate((np.identity(len(vector)),A_matrix.transpose()), axis=1)\n #construct the \"second row\" of the matrix\n left_matrix_second_row = np.concatenate((A_matrix,np.matrix(np.zeros([len(A),len(A)]))), axis=1)\n #combine the whole matrix by combining the rows\n left_matrix = np.concatenate((left_matrix_first_row,left_matrix_second_row),axis = 0)\n #Solve the system of linear equalities from the previous page\n return np.linalg.solve(left_matrix, \\\n np.concatenate((np.matrix(vector).transpose(),\\\n np.zeros([len(A),1])),axis=0))[:len(vector)] \n```\n\n\n```python\n# Example: Project gradient such that A*proj_gradient = 0\nA = [[1,0,0],[0,1,0]]\ngradient = [1,1,1]\nproject_vector(A,gradient)\n```\n\n\n\n\n matrix([[0.],\n [0.],\n [1.]])\n\n\n\n# Example\n\nLet us study optimization problem\n$$\n\\begin{align}\n\\min \\qquad& x_1^2+x_2^2+x_3^2\\\\\n\\text{s.t.}\\qquad &x_1+x_2=3\\\\\n &x_1+x_3=4.\n\\end{align}\n$$\n\nLet us project a negative gradient from a feasible point $x=(1,2,3)$\n\nNow, the matrix\n$$\nA = \\left[\n\\begin{array}{ccc}\n1& 1 & 0\\\\\n1& 0 & 1\n\\end{array}\n\\right]\n$$.\n\n\n```python\nimport ad\nA = [[1,1,0],[1,0,1]]\ngradient = ad.gh(lambda x:x[0]**2+x[1]**2+x[2]**2)[0]([1,2,3])\nprint(gradient)\nd = project_vector(A,[-i for i in gradient])\nprint(d)\n```\n\n [2.0, 4.0, 6.0]\n [[ 2.66666667]\n [-2.66666667]\n [-2.66666667]]\n\n\n### d is a feasible direction\n\n\n```python\nnp.matrix(A)*d\n```\n\n\n\n\n matrix([[0.0000000e+00],\n [4.4408921e-16]])\n\n\n\n### d is a descent direction\n\n\n```python\ndef f(x):\n return x[0]**2+x[1]**2+x[2]**2\nalpha = 0.001\nprint(\"Value of f at [1,2,3] is \"+str(f([1,2,3])))\nx_mod= np.array([1,2,3])+alpha*np.array(d).transpose()[0]\nprint(x_mod)\nprint(\"Value of f at [1,2,3] +alpha*d is \"+str(f(x_mod)))\nprint(\"Gradient dot product direction (i.e., directional derivative) is \" \\\n + str(np.matrix(ad.gh(f)[0]([1,2,3])).dot(np.array(d))))\n```\n\n Value of f at [1,2,3] is 14\n [1.00266667 1.99733333 2.99733333]\n Value of f at [1,2,3] +alpha*d is 13.978687999999998\n Gradient dot product direction (i.e., directional derivative) is [[-21.33333333]]\n\n\n## Finally, the algorithm of the projected gradient\n\n\n```python\nimport numpy as np\nimport ad\ndef projected_gradient_method(f,A,start,step,precision):\n f_old = float('Inf')\n x = np.array(start)\n steps = []\n f_new = f(x)\n iters = 0\n while abs(f_old-f_new)>precision:\n # store the current function value\n f_old = f_new\n # compute gradient\n gradient = ad.gh(f)[0](x)\n # project negative gradient\n d = project_vector(A,[-i for i in gradient])\n # take transpose\n d = d.reshape(1,-1)\n # take step\n x = np.array(x + step*d)[0]\n # compute f in new point+ \n f_new = f(x)\n # record new step\n steps.append(x)\n # update iterations counter\n iters = iters + 1\n return x,f_new,steps,iters\n```\n\n\n```python\nf = lambda x:x[0]**2+x[1]**2+x[2]**2\nA = [[1,1,0],[1,0,1]]\nstart = [1,2,3]\n(x,f_val,steps,iters) = projected_gradient_method(f,A,start,0.6,0.000001)\n```\n\n\n```python\nprint(x)\nprint(f(x))\nprint(f([1,2,3]))\nprint(np.matrix(A)*np.matrix(x).transpose())\nprint(iters)\n```\n\n [2.333248 0.666752 1.666752]\n 8.666666688512\n 14\n [[3.]\n [4.]]\n 6\n\n\n## Note\nIf there are both linear equality and inequality constraints, the projection matrix does not remain the same \n* At each iteration, it includes only the equality and active inequality constraints\n\n# Active set method\nConsider a problem\n$$\n\\min f(x)\\\\\n\\text{s.t. }Ax\\leq b,\n$$\nwhere $A$ is a $l\\times n$ matrix ($l\\leq n$) and $b$ is a vector.\n\n## Idea\n* In $𝑥_k$, the set of constraints is divided into active ($𝑖 ∈ 𝐼$) and inactive constraints\n* Inactive constraints are not taken into account when the search direction $𝑑_k$ is determined\n* Inactive constraints affect only when computing the optimal step length $\\alpha_k$\n\n\n## Feasible directions\n* For $𝑖\\in 𝐼$ , $(𝑎_i)^Tx_k = b_i$\n* If $𝑑_k$ is feasible in $𝑥_k$, then $𝑥_k + \\alpha 𝑑_k \\in 𝑆$ for some $\\alpha > 0$\n* $(𝑎_i)^T(x_k+\\alpha d_k) = (a_i)^Tx_k + \\alpha(a_i)^Td_k\\leq b_i$\n* $(𝑎_i)^Td_k\\leq 0$ for feasible $𝑑_k$ and the constraint remains active if $(𝑎_i)^Td_k=0$\n\n## On active constraints\n* Optimization problem with inequality constraints is more difficult than problem with equality constraints since the active set in a local minimizer is not known\n* If it would be known, then it would be enough to solve a corresponding equality constrained problem\n* In that case, if the other constraints would be satisfied in the solution and all the Lagrange multipliers were non-negative, then the solution would also be a solution to the original problem\n\n## Using active set\n* At each iteration, a working set is considered which consists of the active constraints in $𝑥_k$\n* The direction $𝑑_k$ is determined so that it is a descent direction in the working set\n * E.g. Rosen’s projected gradient method can be used\n\n## Active set algorithm\n1. Choose a starting point $x_1$ and determine an initial active set $I_1$ and set $k=1$\n2. Compute a feasible descent direction $d_k$ in the subspace defined by the active constraints (e.g., by using projected gradient)\n3. If $||d_k||=0$, go to step 6, otherwise, find optimal step length $\\alpha$ by staying in the feasible set and set $x_{k+1} = x_k + \\alpha d_k$\n4. If no new constraint becomes active go to step 7 (active set does not change)\n5. Addition to active set: a new constraint $j$ becomes active, update $I_{k+1} = _kh \\cup \\{j\\}$ and go to step 7\n6. Removal from active set: approximate Lagrangian multipliers $\\mu_i$, $i\\in I_k$. If $\\mu_i\\geq 0$ for all $i$, stop (active set is correct). Otherwise, remove a constraint $j$ with negative multiplier from the active set: $I_{k+1}=I_k\\setminus \\{j\\}$\n7. Set $k=k+1$ and go to step 2\n\nImplementation of the active set method is left as a voluntary exercise \n\n### Note: \n\n* Projected gradient method can also extended for non-linear constraints.\n* But, this needs some extra steps\n\n\n", "meta": {"hexsha": "3a2c989469c9e7d6200ae209d976570bcaa047eb", "size": 21646, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lecture 7, Direct methods for constrained optimization.ipynb", "max_stars_repo_name": "bshavazipour/TIES483-2022", "max_stars_repo_head_hexsha": "93dfabbfe1e953e5c5f83c44412963505ecf575a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lecture 7, Direct methods for constrained optimization.ipynb", "max_issues_repo_name": "bshavazipour/TIES483-2022", "max_issues_repo_head_hexsha": "93dfabbfe1e953e5c5f83c44412963505ecf575a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lecture 7, Direct methods for constrained optimization.ipynb", "max_forks_repo_name": "bshavazipour/TIES483-2022", "max_forks_repo_head_hexsha": "93dfabbfe1e953e5c5f83c44412963505ecf575a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-03T09:40:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-03T09:40:02.000Z", "avg_line_length": 25.8614097969, "max_line_length": 269, "alphanum_fraction": 0.5240691121, "converted": true, "num_tokens": 3422, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3923368301671084, "lm_q2_score": 0.35220176844875106, "lm_q1q2_score": 0.1381817254124329}}
{"text": "# Announcements\n\n* Today we will continue with our radioactivity lecture\n* Friday we will go over exam results and CP1 (which will be posted Friday). \n* The homework will be over radioactive decay and include some review material on common issues from the exam \n\n\n```python\n%matplotlib widget\n\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport mplcursors\n```\n\n\n```python\n# Scale plot to fit page \nplt.rcParams[\"figure.figsize\"] = (8, 6)\nplt.rcParams[\"font.size\"] = 16\nplt.rcParams[\"\"]\n```\n\n## Review\n\n### Radioactive Decay\n\nEarlier last week we derived the decay equation:\n\n\n\\begin{align}\n \\frac{dN}{dt} &= -\\lambda N \\\\\n \\Rightarrow N_i(t) &= N_i(0)e^{-\\lambda t}\\\\\n\\end{align}\n\nwhere\n\n\\begin{align}\n N_i(t) &= \\mbox{number of isotopes i adjusted for decay}\\\\\n N_i(0)&= \\mbox{initial condition}\\\\\n \\end{align}\n \nWe also defined our decay constant $\\lambda$ and how it relates to the half-life of an isotope\n\n\\begin{align}\n A = N\\lambda \\\\\n \\lambda = \\frac{ln(2)}{\\tau_{1/2}} \\\\\n \\end{align}\n \n### Radioactive decay with a stable daughter product\n\nIf the decay of an element goes into a stable daughter, then the buildup of the daughter looks like: \n\ngiven the parent decay\n\\begin{align}\nN_1(t) = N_1(0)\\exp{^{\\lambda t}}\n\\end{align}\n\nthe daugter buildup is the eqivalent of the nuclides lost from the parent:\n\\begin{align}\nN_2(t) = N_1(0)\\left[1-\\exp{^{\\lambda t}}\\right]\n\\end{align}\n\nif you know $N_2(t)$ and $N_1(t)$, you can calcualte how long a sample has been decaying\n\\begin{align}\nt = \\frac{1}{\\lambda_1}ln\\left(1+\\frac{N_2(t)}{N_1(t)}\\right)\n\\end{align}\n \n### And radioactive decay with production\n\n\\begin{align}\n\\frac{dN(t)}{dt} &= -\\mbox{rate of decay} + \\mbox{rate of production}\\\\\n\\implies N(t) &= N_0 e^{-\\lambda t} + \\int_0^t dt'Q(t')e^{-\\lambda (t-t')}\\\\\n\\end{align}\n\nIf the production rate is constant $(Q(t)=Q_0)$, this simplifies:\n\n\\begin{align}\nN(t) &= N_0 e^{-\\lambda t} + \\frac{Q_0}{\\lambda}\\left[1-e^{-\\lambda t}\\right]\\\\\n\\end{align}\n\n## Radioactivity part 2, decay dynamics\n\nIn radioactive decay we can have long chains of unstable nuclei. This is common in the heavy nuclei. \n\nCC BY-SA 3.0 , Link
\n\n## Series Decay Calculations\n\nIn these series, calculating activities of many products gets quite complex. Let's formulate some equations for a three decay series: \n\nEach series begins with $N_1$, which is governed by a familiar equation:\n\\begin{align}\n \\frac{dN_1}{dt} &= -\\lambda_1 N_1 \\\\\n\\end{align}\n\nThe second nuclide in the series is produced by a rate of the parents decay, and is removed by its own decay\n\n\\begin{align}\n \\frac{dN_2}{dt} &= \\mbox{+decay of parent - decay of itself}\\\\\n &= \\lambda_1 N_1 -\\lambda_2 N_2 \\\\\n\\end{align}\n\nThe next isotope in the series is similar:\n\n\n\\begin{align}\n \\frac{dN_3}{dt} &= \\mbox{+decay of parent - decay of itself}\\\\\n &= \\lambda_2 N_2 -\\lambda_3 N_3 \\\\\n\\end{align}\n\nThe $i$th in the series is:\n\n\\begin{align}\n \\frac{dN_i}{dt} &= \\mbox{+decay of parent - decay of itself}\\\\\n &= \\lambda_{i-1} N_{i-1} -\\lambda_i N_i \\\\\n\\end{align}\n\n### Solutions to a multi-component decay\n\n#### Nuclide 1\n\nThe solution for the first nuclide in the series is something we've already solved\n\n\\begin{align}\n N_1(t) &= N_1(0)e^{-\\lambda_1*t}\n\\end{align}\n\n#### Nuclide 2 \n\nWe can use this solution in our general formulation for Nuclide 2 \n\n\\begin{align}\n \\frac{dN_2}{dt} &= \\lambda_1 N_1 -\\lambda_2 N_2 \\\\\n &= \\lambda_1 N_1(0)e^{-\\lambda_1*t} - \\lambda_2 N_2 \\\\\n \\frac{dN_2}{dt} + \\lambda_2 N_2 &= \\lambda_1 N_1(0)e^{-\\lambda_1*t}\n\\end{align}\n\nWe can use the integrating factor $e^{-\\lambda_2 t}$ to solve this\n\n\\begin{align}\ne^{-\\lambda_2 t}\\frac{dN_2}{dt} + e^{-\\lambda_2 t}\\lambda_2 N_2 &= \\lambda_1 N_1(0)e^{(\\lambda_2-\\lambda_1)*t} \\\\ \n\\frac{d}{dt}\\left(N_2 e^{\\lambda_2*t}\\right) &= \\lambda_1 N_1(0)e^{(\\lambda_2-\\lambda_1)*t}\n\\end{align}\n\nWe can integrate this\n\n\\begin{align}\nN_2e^{\\lambda_2t} &= \\frac{\\lambda_1}{\\lambda_2-\\lambda_1}N_1(0)e^{\\lambda_2-lambda_1}t + C \\\\\nC &= \\frac{\\lambda_1}{\\lambda_2-lambda_1}N_1(0)\n\\end{align}\n\nSo $N_2$ as a function of time is: \n\\begin{align}\nN_2(t) = \\frac{\\lambda_1}{\\lambda_2-\\lambda_1}N_1(0)\\left(e^{-\\lambda_1t}-e^{-\\lambda_2t}\\right)\n\\end{align}\n\n#### Nuclide 3 \n\n\\begin{align}\n \\frac{dN_3}{dt} &= \\lambda_2 N_2 -\\lambda_3 N_3 \\\\\n\\end{align}\n\nWe use a similar process as our solution to nuclide 2. The solution is:\n\n\\begin{align}\n N_3(t) &= \\lambda_1 \\lambda_2 N_1(0)\\left[\\frac{e^{-\\lambda_1t}}{(\\lambda_2-\\lambda_1)(\\lambda_3-\\lambda_1)}+\\frac{e^{-\\lambda_2t}}{(\\lambda_1-\\lambda_2)(\\lambda_3-\\lambda_2)}+ \\frac{e^{-\\lambda_3t}}{(\\lambda_1-\\lambda_3)(\\lambda_2-\\lambda_3)}\\right] \\\\\n\\end{align}\n\nIf Nuclide 3 is *stable*, this looks like:\n\n\\begin{align}\nN_3(t) &= N_1(0)\\left(1 - \\frac{\\lambda_2}{\\lambda_2-\\lambda_1}e^{-\\lambda_1t} - \\frac{\\lambda_1}{\\lambda_1-\\lambda_2}e^{-\\lambda_2t}\\right)\n\\end{align}\n\n\n#### The batemann equations\n\nIf you continue the series farther past three daughters, the solutions have a generalized form called the **batemann equations**. These are used throughout nuclear engineering, and especially in fuel cycles. \n\n### Transient Equilibrium $t_{p}>t_d$\n\n### Secular Equilibrium $t_{p}>>t_d$\n\n### Daughter Decays Slower than parent $t_p < t_d$\n\n### Daughter is Stable $t_d = 0$\n\n\n```python\nimport math\ndef n_decay(t, n_initial=100, lam=0.4):\n \"\"\"This function describes the decay of an isotope\"\"\"\n return n_initial*math.exp(-lam*t)\n\n\n# This code plots the decay of an isotope\nimport numpy as np\ny = np.arange(26.0)\nx = np.arange(26.0)\nfor t in range(0,26):\n x[t] = t\n y[t] = n_decay(t)\n \n# creates a figure and axes with matplotlib\nfig, ax = plt.subplots()\nscatter = plt.scatter(x, y, color='blue', s=y*20, alpha=0.4) \nax.plot(x, y, color='red') \n\n# adds labels to the plot\nax.set_ylabel('N_i(t)')\nax.set_xlabel('Time')\nax.set_title('N_i')\n\n# adds tooltips\nimport mpld3\nlabels = ['{0}% remaining'.format(i) for i in y]\n\ntooltip = mpld3.plugins.PointLabelTooltip(scatter, labels=labels)\nmpld3.plugins.connect(fig, tooltip)\n\nmpld3.display()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e694dfc7f2a83edf0ed4beeab6710e4a5adbc3e5", "size": 12595, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10.05-radioactivity/01-radioactivity.ipynb", "max_stars_repo_name": "munkm/npre247", "max_stars_repo_head_hexsha": "5683fa3176e946622a31e3b207484e7ec74f8421", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-01-31T17:44:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T19:54:50.000Z", "max_issues_repo_path": "10.05-radioactivity/01-radioactivity.ipynb", "max_issues_repo_name": "munkm/npre247", "max_issues_repo_head_hexsha": "5683fa3176e946622a31e3b207484e7ec74f8421", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2022-01-28T20:32:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-31T17:43:54.000Z", "max_forks_repo_path": "10.05-radioactivity/01-radioactivity.ipynb", "max_forks_repo_name": "munkm/npre247", "max_forks_repo_head_hexsha": "5683fa3176e946622a31e3b207484e7ec74f8421", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2022-01-24T16:47:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T04:09:25.000Z", "avg_line_length": 38.9938080495, "max_line_length": 850, "alphanum_fraction": 0.553394204, "converted": true, "num_tokens": 2259, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.2782567937024021, "lm_q1q2_score": 0.13804147836412428}}
{"text": "# Homework 4: Word-level entailment with neural networks\n\n\n```python\n__author__ = \"Christopher Potts\"\n__version__ = \"CS224u, Stanford, Spring 2019\"\n```\n\n## Contents\n\n1. [Overview](#Overview)\n1. [Set-up](#Set-up)\n1. [Data](#Data)\n 1. [Edge disjoint](#Edge-disjoint)\n 1. [Word disjoint](#Word-disjoint)\n1. [Baseline](#Baseline)\n 1. [Representing words: vector_func](#Representing-words:-vector_func)\n 1. [Combining words into inputs: vector_combo_func](#Combining-words-into-inputs:-vector_combo_func)\n 1. [Classifier model](#Classifier-model)\n 1. [Baseline results](#Baseline-results)\n1. [Homework questions](#Homework-questions)\n 1. [Hypothesis-only baseline [2 points]](#Hypothesis-only-baseline-[2-points])\n 1. [Alternatives to concatenation [1 point]](#Alternatives-to-concatenation-[1-point])\n 1. [A deeper network [2 points]](#A-deeper-network-[2-points])\n 1. [Your original system [4 points]](#Your-original-system-[4-points])\n1. [Bake-off [1 point]](#Bake-off-[1-point])\n\n## Overview\n\nThe general problem is word-level natural language inference.\n\nTraining examples are pairs of words $(w_{L}, w_{R}), y$ with $y = 1$ if $w_{L}$ entails $w_{R}$, otherwise $0$.\n\nThe homework questions below ask you to define baseline models for this and develop your own system for entry in the bake-off, which will take place on a held-out test-set distributed at the start of the bake-off. (Thus, all the data you have available for development is available for training your final system before the bake-off begins.)\n\n\n\n## Set-up\n\nSee [the first notebook in this unit](nli_01_task_and_data.ipynb) for set-up instructions.\n\n\n```python\nfrom collections import defaultdict\nimport json\nimport numpy as np\nimport os\nimport pandas as pd\nfrom torch_shallow_neural_classifier import TorchShallowNeuralClassifier\nimport nli\nimport utils\n```\n\n\n```python\nDATA_HOME = 'data'\n\nNLIDATA_HOME = os.path.join(DATA_HOME, 'nlidata')\n\nwordentail_filename = os.path.join(\n NLIDATA_HOME, 'nli_wordentail_bakeoff_data.json')\n\nGLOVE_HOME = os.path.join(DATA_HOME, 'glove.6B')\n```\n\n## Data\n\nI've processed the data into two different train/test splits, in an effort to put some pressure on our models to actually learn these semantic relations, as opposed to exploiting regularities in the sample.\n\n* `edge_disjoint`: The `train` and `dev` __edge__ sets are disjoint, but many __words__ appear in both `train` and `dev`.\n* `word_disjoint`: The `train` and `dev` __vocabularies are disjoint__, and thus the edges are disjoint as well.\n\nThese are very different problems. For `word_disjoint`, there is real pressure on the model to learn abstract relationships, as opposed to memorizing properties of individual words.\n\n\n```python\nwith open(wordentail_filename) as f:\n wordentail_data = json.load(f)\n```\n\nThe outer keys are the splits plus a list giving the vocabulary for the entire dataset:\n\n\n```python\nwordentail_data.keys()\n```\n\n\n\n\n dict_keys(['edge_disjoint', 'vocab', 'word_disjoint'])\n\n\n\n### Edge disjoint\n\n\n```python\nwordentail_data['edge_disjoint'].keys()\n```\n\n\n\n\n dict_keys(['dev', 'train'])\n\n\n\nThis is what the split looks like; all three have this same format:\n\n\n```python\nwordentail_data['edge_disjoint']['dev'][: 5]\n```\n\n\n\n\n [[['sweater', 'stroke'], 0],\n [['constipation', 'hypovolemia'], 0],\n [['disease', 'inflammation'], 0],\n [['herring', 'animal'], 1],\n [['cauliflower', 'outlook'], 0]]\n\n\n\nLet's test to make sure no edges are shared between `train` and `dev`:\n\n\n```python\nnli.get_edge_overlap_size(wordentail_data, 'edge_disjoint')\n```\n\n\n\n\n 0\n\n\n\nAs we expect, a *lot* of vocabulary items are shared between `train` and `dev`:\n\n\n```python\nnli.get_vocab_overlap_size(wordentail_data, 'edge_disjoint')\n```\n\n\n\n\n 2916\n\n\n\nThis is a large percentage of the entire vocab:\n\n\n```python\nlen(wordentail_data['vocab'])\n```\n\n\n\n\n 8470\n\n\n\nHere's the distribution of labels in the `train` set. It's highly imbalanced, which will pose a challenge for learning. (I'll go ahead and reveal that the `dev` set is similarly distributed.)\n\n\n```python\ndef label_distribution(split):\n return pd.DataFrame(wordentail_data[split]['train'])[1].value_counts()\n```\n\n\n```python\nlabel_distribution('edge_disjoint')\n```\n\n\n\n\n 0 14650\n 1 2745\n Name: 1, dtype: int64\n\n\n\n### Word disjoint\n\n\n```python\nwordentail_data['word_disjoint'].keys()\n```\n\n\n\n\n dict_keys(['dev', 'train'])\n\n\n\nIn the `word_disjoint` split, no __words__ are shared between `train` and `dev`:\n\n\n```python\nnli.get_vocab_overlap_size(wordentail_data, 'word_disjoint')\n```\n\n\n\n\n 0\n\n\n\nBecause no words are shared between `train` and `dev`, no edges are either:\n\n\n```python\nnli.get_edge_overlap_size(wordentail_data, 'word_disjoint')\n```\n\n\n\n\n 0\n\n\n\nThe label distribution is similar to that of `edge_disjoint`, though the overall number of examples is a bit smaller:\n\n\n```python\nlabel_distribution('word_disjoint')\n```\n\n\n\n\n 0 7199\n 1 1349\n Name: 1, dtype: int64\n\n\n\n## Baseline\n\nEven in deep learning, __feature representation is vital and requires care!__ For our task, feature representation has two parts: representing the individual words and combining those representations into a single network input.\n\n### Representing words: vector_func\n\nLet's consider two baseline word representations methods:\n\n1. Random vectors (as returned by `utils.randvec`).\n1. 50-dimensional GloVe representations.\n\n\n```python\ndef randvec(w, n=50, lower=-1.0, upper=1.0):\n \"\"\"Returns a random vector of length `n`. `w` is ignored.\"\"\"\n return utils.randvec(n=n, lower=lower, upper=upper)\n```\n\n\n```python\n# Any of the files in glove.6B will work here:\n\nglove_dim = 50\n\nglove_src = os.path.join(GLOVE_HOME, 'glove.6B.{}d.txt'.format(glove_dim))\n\n# Creates a dict mapping strings (words) to GloVe vectors:\nGLOVE = utils.glove2dict(glove_src)\n\ndef glove_vec(w): \n \"\"\"Return `w`'s GloVe representation if available, else return \n a random vector.\"\"\"\n return GLOVE.get(w, randvec(w, n=glove_dim))\n```\n\n### Combining words into inputs: vector_combo_func\n\nHere we decide how to combine the two word vectors into a single representation. In more detail, where `u` is a vector representation of the left word and `v` is a vector representation of the right word, we need a function `vector_combo_func` such that `vector_combo_func(u, v)` returns a new input vector `z` of dimension `m`. A simple example is concatenation:\n\n\n```python\ndef vec_concatenate(u, v):\n \"\"\"Concatenate np.array instances `u` and `v` into a new np.array\"\"\"\n return np.concatenate((u, v))\n```\n\n`vector_combo_func` could instead be vector average, vector difference, etc. (even combinations of those) – there's lots of space for experimentation here; [homework question 2](#Alternatives-to-concatenation-[1-point]) below pushes you to do some exploration.\n\n### Classifier model\n\nFor a baseline model, I chose `TorchShallowNeuralClassifier`:\n\n\n```python\nnet = TorchShallowNeuralClassifier(hidden_dim=50, max_iter=100)\n```\n\n### Baseline results\n\nThe following puts the above pieces together, using `vector_func=glove_vec`, since `vector_func=randvec` seems so hopelessly misguided for `word_disjoint`!\n\n\n```python\nword_disjoint_experiment = nli.wordentail_experiment(\n train_data=wordentail_data['word_disjoint']['train'],\n assess_data=wordentail_data['word_disjoint']['dev'], \n model=net, \n vector_func=glove_vec,\n vector_combo_func=vec_concatenate)\n```\n\n Finished epoch 100 of 100; error is 0.022624022560194135\n\n precision recall f1-score support\n \n 0 0.92 0.92 0.92 1910\n 1 0.36 0.35 0.36 239\n \n micro avg 0.86 0.86 0.86 2149\n macro avg 0.64 0.64 0.64 2149\n weighted avg 0.86 0.86 0.86 2149\n \n\n\n## Homework questions\n\nPlease embed your homework responses in this notebook, and do not delete any cells from the notebook. (You are free to add as many cells as you like as part of your responses.)\n\n### Hypothesis-only baseline [2 points]\n\nDuring our discussion of SNLI and MultiNLI, we noted that a number of research teams have shown that hypothesis-only baselines for inference tasks can be remarkably robust. This question asks you to explore briefly how this baseline effects the 'edge_disjoint' and 'word_disjoint' versions of our task.\n\nFor this problem, submit code the following:\n\n1. A `vector_combo_func` function called `hypothesis_only` that simply throws away the premise, using the unmodified hypothesis (second) vector as its representation of the example.\n\n1. Code for looping over the two conditions 'word_disjoint' and 'edge_disjoint' and the two `vector_combo_func` values `vec_concatenate` and `hypothesis_only`, calling `nli.wordentail_experiment` to train on the conditions 'train' portion and assess on its 'dev' portion, with `glove50vec` as the `vector_func`. So that the results are consistent, use an `sklearn.linear_model.LogisticRegression` with default parameters as the model.\n\n1. Print out the percentage-wise increase in macro-F1 over the `hypothesis_only` delivers over `vec_concatenate` for each of the two conditions. For example, if `hypothesis_only` returns 0.5 for condition `C` and `vec_concatenate` delivers 0.75 for `C`, then you'd report a 50% increase for `C`. The values you need are stored in the dictionary returned by `nli.wordentail_experiment`, with key 'macro-F1'. Please use two digits of precision for the increases.\n\n\n```python\nimport sklearn\n```\n\n\n```python\n#1. hypothesis_only\ndef hypothesis_only(u,v):\n return v\n```\n\n\n```python\n# 2. looping over two conditions and two vector_combo_func\nconditions = ['word_disjoint', 'edge_disjoint']\ncombo_funcs = [vec_concatenate, hypothesis_only]\n# create a dictionary for the macro F1 score\nmacroF1_dict = {}\nfor i in range(len(conditions)):\n for j in range(len(combo_funcs)):\n print(\"conditions:\", conditions[i])\n print(\"combo functions:\", j)\n word_disjoint_experiment = nli.wordentail_experiment(\n train_data=wordentail_data[conditions[i]]['train'],\n assess_data=wordentail_data[conditions[i]]['dev'], \n model=sklearn.linear_model.LogisticRegression(), \n vector_func=glove_vec,\n vector_combo_func=combo_funcs[j])\n macroF1_dict[(conditions[i], combo_funcs[j])] = word_disjoint_experiment['macro-F1']\n```\n\n conditions: word_disjoint\n combo functions: 0\n\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.90 0.98 0.94 1910\n 1 0.48 0.15 0.22 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.69 0.56 0.58 2149\n weighted avg 0.85 0.89 0.86 2149\n \n conditions: word_disjoint\n combo functions: 1\n\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.89 0.99 0.94 1910\n 1 0.25 0.03 0.06 239\n \n micro avg 0.88 0.88 0.88 2149\n macro avg 0.57 0.51 0.50 2149\n weighted avg 0.82 0.88 0.84 2149\n \n conditions: edge_disjoint\n combo functions: 0\n\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.88 0.97 0.92 7376\n 1 0.58 0.23 0.33 1321\n \n micro avg 0.86 0.86 0.86 8697\n macro avg 0.73 0.60 0.62 8697\n weighted avg 0.83 0.86 0.83 8697\n \n conditions: edge_disjoint\n combo functions: 1\n\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.87 0.98 0.92 7376\n 1 0.59 0.20 0.30 1321\n \n micro avg 0.86 0.86 0.86 8697\n macro avg 0.73 0.59 0.61 8697\n weighted avg 0.83 0.86 0.83 8697\n \n\n\n\n```python\n# Print out the percentage-wise increase \n#in macro-F1 over the hypothesis_only delivers over vec_concatenate for each of the two conditions. \nmacroF1_dict\n```\n\n\n\n\n {('word_disjoint',\n ): 0.5818232403154631,\n ('word_disjoint',\n ): 0.4978590088855942,\n ('edge_disjoint',\n ): 0.623656138011501,\n ('edge_disjoint',\n ): 0.6079517065797235}\n\n\n\n\n```python\nprint(\"percentage-wise increase for word_disjoint is:\", \n str( round((0.5803144224196856 - 0.5166301461305162) / 0.5166301461305162 * 100, 2) ) + '%')\nprint(\"percentage-wise increase for edge_disjoint is:\",\n str( round((0.6270230030253002 - 0.6089775423004441) / 0.6089775423004441 * 100, 2) ) + '%')\n\n```\n\n percentage-wise increase for word_disjoint is: 12.33%\n percentage-wise increase for edge_disjoint is: 2.96%\n\n\n### Alternatives to concatenation [1 point]\n\nWe've so far just used vector concatenation to represent the premise and hypothesis words. This question asks you to explore a simple alternative. \n\nFor this problem, submit code the following:\n\n1. A new potential value for `vector_combo_func` that does something different from concatenation. Options include, but are not limited to, element-wise addition, difference, and multiplication. These can be combined with concatenation if you like.\n1. Include a use of `nli.wordentail_experiment` in the same configuration as the one in [Baseline results](#Baseline-results) above, but with your new value of `vector_combo_func`.\n\n\n```python\ndef alter_vec_concatenate(u, v):\n \"\"\"Concatenate np.array instances `u` and `v` into a new np.array\"\"\"\n concatenate_v = np.concatenate((u, v))\n addition_v = np.multiply(u,v)\n return np.concatenate((concatenate_v, addition_v))\n```\n\n\n```python\nalternative_experiment = nli.wordentail_experiment(\n train_data=wordentail_data['word_disjoint']['train'],\n assess_data=wordentail_data['word_disjoint']['dev'], \n model=net, \n vector_func=glove_vec,\n vector_combo_func=alter_vec_concatenate)\n```\n\n Finished epoch 100 of 100; error is 0.012377092614769936\n\n precision recall f1-score support\n \n 0 0.93 0.94 0.94 1910\n 1 0.48 0.44 0.46 239\n \n micro avg 0.88 0.88 0.88 2149\n macro avg 0.70 0.69 0.70 2149\n weighted avg 0.88 0.88 0.88 2149\n \n\n\n### A deeper network [2 points]\n\nIt is very easy to subclass `TorchShallowNeuralClassifier` if all you want to do is change the network graph: all you have to do is write a new `define_graph`. If your graph has new arguments that the user might want to set, then you should also redefine `__init__` so that these values are accepted and set as attributes.\n\nFor this question, please subclass `TorchShallowNeuralClassifier` so that it defines the following graph:\n\n$$\\begin{align}\nh_{1} &= xW_{1} + b_{1} \\\\\nr_{1} &= \\textbf{Bernoulli}(1 - \\textbf{dropout_prob}, n) \\\\\nd_{1} &= r_1 * h_{1} \\\\\nh_{2} &= f(d_{1}) \\\\\nh_{3} &= h_{2}W_{2} + b_{2}\n\\end{align}$$\n\nHere, $r_{1}$ and $d_{1}$ define a dropout layer: $r_{1}$ is a random binary vector of dimension $n$, where the probability of a value being $1$ is given by $1 - \\textbf{dropout_prob}$. $r_{1}$ is multiplied element-wise by our first hidden representation, thereby zeroing out some of the values. The result is fed to the user's activation function $f$, and the result of that is fed through another linear layer to produce $h_{3}$. (Inside `TorchShallowNeuralClassifier`, $h_{3}$ is the basis for a softmax classifier, so no activation function is applied to it.)\n\nFor comparison, using this notation, `TorchShallowNeuralClassifier` defines the following graph:\n\n$$\\begin{align}\nh_{1} &= xW_{1} + b_{1} \\\\\nh_{2} &= f(h_{1}) \\\\\nh_{3} &= h_{2}W_{2} + b_{2}\n\\end{align}$$\n\nThe following code starts this sub-class for you, so that you can concentrate on `define_graph`. Be sure to make use of `self.dropout_prob`\n\nFor this problem, submit just your completed `TorchDeepNeuralClassifier`. You needn't evaluate it, though we assume you will be keen to do that!\n\n\n```python\nimport torch.nn as nn\n\nclass TorchDeepNeuralClassifier(TorchShallowNeuralClassifier):\n def __init__(self, dropout_prob=0.7, **kwargs):\n self.dropout_prob = dropout_prob\n super().__init__(**kwargs)\n \n def define_graph(self):\n \"\"\"Complete this method!\n \n Returns\n -------\n an `nn.Module` instance, which can be a free-standing class you \n write yourself, as in `torch_rnn_classifier`, or the outpiut of \n `nn.Sequential`, as in `torch_shallow_neural_classifier`.\n \n \"\"\"\n \n return nn.Sequential(\n nn.Linear(self.input_dim, self.hidden_dim),\n nn.Dropout(p=self.dropout_prob),\n self.hidden_activation,\n nn.Linear(self.hidden_dim, self.n_classes_))\n \n```\n\n\n```python\nfrom sklearn.datasets import load_digits\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.metrics import classification_report, accuracy_score\n\ndigits = load_digits()\nX = digits.data\ny = digits.target\n\nX_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=0.33, random_state=42)\n\nmod = TorchDeepNeuralClassifier()\n\nprint(mod)\n\nmod.fit(X_train, y_train)\npredictions = mod.predict(X_test)\n\nprint(\"\\nClassification report:\")\n\nprint(classification_report(y_test, predictions))\n\nprint(accuracy_score(y_test, predictions))\n```\n\n Finished epoch 1 of 100; error is 4.541479587554932\n\n TorchDeepNeuralClassifier(\n \thidden_dim=50,\n \thidden_activation=Tanh(),\n \tbatch_size=1028,\n \tmax_iter=100,\n \teta=0.01,\n \toptimizer=,\n \tl2_strength=0)\n\n\n Finished epoch 100 of 100; error is 1.0376653373241425\n\n \n Classification report:\n precision recall f1-score support\n \n 0 1.00 0.96 0.98 55\n 1 0.93 0.91 0.92 55\n 2 0.91 1.00 0.95 52\n 3 0.93 0.89 0.91 56\n 4 0.94 0.97 0.95 64\n 5 0.93 0.95 0.94 73\n 6 0.93 0.98 0.96 57\n 7 1.00 0.98 0.99 62\n 8 0.91 0.92 0.91 52\n 9 0.95 0.87 0.91 68\n \n micro avg 0.94 0.94 0.94 594\n macro avg 0.94 0.94 0.94 594\n weighted avg 0.94 0.94 0.94 594\n \n 0.9427609427609428\n\n\n### Your original system [4 points]\n\nThis is a simple dataset, but our focus on the 'word_disjoint' condition ensures that it's a challenging one, and there are lots of modeling strategies one might adopt. \n\nYou are free to do whatever you like. We require only that your system differ in some way from those defined in the preceding questions. They don't have to be completely different, though. For example, you might want to stick with the model but represent examples differently, or the reverse.\n\nKeep in mind that, for the bake-off evaluation, the 'edge_disjoint' portions of the data are off limits. You can, though, train on the combination of the 'word_disjoint' 'train' and 'dev' portions. You are free to use different pretrained word vectors and the like. Please do not introduce additional entailment datasets into your training data, though.\n\nPlease embed your code in this notebook so that we can rerun it.\n\n\n```python\n# explore different models\nfrom sklearn import model_selection\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.svm import SVC\n\n# prepare models\nmodels = []\nmodels.append(('LR', LogisticRegression()))\nmodels.append(('LDA', LinearDiscriminantAnalysis()))\nmodels.append(('KNN', KNeighborsClassifier()))\nmodels.append(('CART', DecisionTreeClassifier()))\nmodels.append(('NB', GaussianNB()))\nmodels.append(('SVM', SVC()))\n```\n\n\n```python\n# using alter_vec_concatenate function\nmacroF1_dict = {}\nfor name, model in models:\n word_disjoint_experiment = nli.wordentail_experiment(\n train_data=wordentail_data['word_disjoint']['train'],\n assess_data=wordentail_data['word_disjoint']['dev'], \n model=model, \n vector_func=glove_vec,\n vector_combo_func=alter_vec_concatenate)\n macroF1_dict[name] = word_disjoint_experiment['macro-F1']\n \n\n```\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.92 0.97 0.94 1910\n 1 0.53 0.30 0.38 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.72 0.63 0.66 2149\n weighted avg 0.87 0.89 0.88 2149\n \n precision recall f1-score support\n \n 0 0.91 0.97 0.94 1910\n 1 0.54 0.28 0.37 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.73 0.62 0.65 2149\n weighted avg 0.87 0.89 0.88 2149\n \n precision recall f1-score support\n \n 0 0.91 0.93 0.92 1910\n 1 0.31 0.25 0.28 239\n \n micro avg 0.86 0.86 0.86 2149\n macro avg 0.61 0.59 0.60 2149\n weighted avg 0.84 0.86 0.85 2149\n \n precision recall f1-score support\n \n 0 0.90 0.84 0.87 1910\n 1 0.18 0.29 0.23 239\n \n micro avg 0.78 0.78 0.78 2149\n macro avg 0.54 0.57 0.55 2149\n weighted avg 0.82 0.78 0.80 2149\n \n precision recall f1-score support\n \n 0 0.93 0.87 0.90 1910\n 1 0.32 0.51 0.40 239\n \n micro avg 0.83 0.83 0.83 2149\n macro avg 0.63 0.69 0.65 2149\n weighted avg 0.87 0.83 0.84 2149\n \n\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/svm/base.py:196: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n \"avoid this warning.\", FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.90 1.00 0.95 1910\n 1 0.85 0.14 0.24 239\n \n micro avg 0.90 0.90 0.90 2149\n macro avg 0.88 0.57 0.60 2149\n weighted avg 0.90 0.90 0.87 2149\n \n\n\n\n```python\nmacroF1_dict\n```\n\n\n\n\n {'LR': 0.6609217738768122,\n 'LDA': 0.6537424265984265,\n 'KNN': 0.5973378736366588,\n 'CART': 0.5483229562403265,\n 'NB': 0.6480074347308773,\n 'SVM': 0.5956134882605116}\n\n\n\n\n```python\n# using original vec_concatenate function\nmacroF1_dict_original = {}\nfor name, model in models:\n word_disjoint_experiment = nli.wordentail_experiment(\n train_data=wordentail_data['word_disjoint']['train'],\n assess_data=wordentail_data['word_disjoint']['dev'], \n model=model, \n vector_func=glove_vec,\n vector_combo_func=vec_concatenate)\n macroF1_dict_original[name] = word_disjoint_experiment['macro-F1']\n \n\n```\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/linear_model/logistic.py:433: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.\n FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.90 0.98 0.94 1910\n 1 0.49 0.16 0.24 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.70 0.57 0.59 2149\n weighted avg 0.86 0.89 0.86 2149\n \n precision recall f1-score support\n \n 0 0.90 0.98 0.94 1910\n 1 0.51 0.18 0.26 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.71 0.58 0.60 2149\n weighted avg 0.86 0.89 0.86 2149\n \n precision recall f1-score support\n \n 0 0.91 0.94 0.92 1910\n 1 0.36 0.29 0.32 239\n \n micro avg 0.86 0.86 0.86 2149\n macro avg 0.64 0.61 0.62 2149\n weighted avg 0.85 0.86 0.86 2149\n \n precision recall f1-score support\n \n 0 0.90 0.86 0.88 1910\n 1 0.19 0.27 0.22 239\n \n micro avg 0.79 0.79 0.79 2149\n macro avg 0.55 0.56 0.55 2149\n weighted avg 0.82 0.79 0.81 2149\n \n precision recall f1-score support\n \n 0 0.92 0.87 0.89 1910\n 1 0.29 0.44 0.35 239\n \n micro avg 0.82 0.82 0.82 2149\n macro avg 0.61 0.65 0.62 2149\n weighted avg 0.85 0.82 0.83 2149\n \n\n\n /home/teng/anaconda3/envs/nlu/lib/python3.7/site-packages/sklearn/svm/base.py:196: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n \"avoid this warning.\", FutureWarning)\n\n\n precision recall f1-score support\n \n 0 0.90 1.00 0.94 1910\n 1 0.81 0.07 0.13 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.85 0.53 0.54 2149\n weighted avg 0.89 0.89 0.85 2149\n \n\n\n\n```python\nmacroF1_dict_original\n```\n\n\n\n\n {'LR': 0.5896050403454263,\n 'LDA': 0.6005052051439069,\n 'KNN': 0.6227195113152642,\n 'CART': 0.5519613010529768,\n 'NB': 0.6207705823123246,\n 'SVM': 0.5374004648150265}\n\n\n\n\n```python\n# conclusion: using LDA/LR + alter_vec_concatenate produced relatively high results\n```\n\n## Bake-off [1 point]\n\nThe goal of the bake-off is to achieve the highest macro-average F1 score on __word_disjoint__, on a test set that we will make available at the start of the bake-off on May 6. The announcement will go out on Piazza. To enter, you'll be asked to run `nli.bake_off_evaluation` on the output of your chosen `nli.wordentail_experiment` run. \n\nTo enter the bake-off, upload this notebook on Canvas:\n\nhttps://canvas.stanford.edu/courses/99711/assignments/187250\n\nThe cells below this one constitute your bake-off entry.\n\nThe rules described in the [Your original system](#Your-original-system-[4-points]) homework question are also in effect for the bake-off.\n\nSystems that enter will receive the additional homework point, and systems that achieve the top score will receive an additional 0.5 points. We will test the top-performing systems ourselves, and only systems for which we can reproduce the reported results will win the extra 0.5 points.\n\nThe bake-off will close at 4:30 pm on May 8. Late entries will be accepted, but they cannot earn the extra 0.5 points. Similarly, you cannot win the bake-off unless your homework is submitted on time.\n\n\n```python\n# Enter your bake-off assessment code into this cell. \n# Please do not remove this comment.\ntest_data_filename = os.path.join(\n NLIDATA_HOME,\n \"bakeoff4-wordentail-data\",\n \"nli_wordentail_bakeoff_data-test.json\")\n\nmodel = LinearDiscriminantAnalysis()\n\nword_disjoint_experiment = nli.wordentail_experiment(\n train_data=wordentail_data['word_disjoint']['train'],\n assess_data=wordentail_data['word_disjoint']['dev'], \n model=model, \n vector_func=glove_vec,\n vector_combo_func=alter_vec_concatenate)\n\nnli.bake_off_evaluation(\n word_disjoint_experiment,\n test_data_filename) \n\n```\n\n precision recall f1-score support\n \n 0 0.91 0.97 0.94 1910\n 1 0.54 0.28 0.37 239\n \n micro avg 0.89 0.89 0.89 2149\n macro avg 0.73 0.62 0.65 2149\n weighted avg 0.87 0.89 0.88 2149\n \n precision recall f1-score support\n \n 0 0.86 0.95 0.90 1767\n 1 0.68 0.38 0.49 446\n \n micro avg 0.84 0.84 0.84 2213\n macro avg 0.77 0.67 0.69 2213\n weighted avg 0.82 0.84 0.82 2213\n \n\n\n\n```python\n# On an otherwise blank line in this cell, please enter\n# your macro-avg f1 value as reported by the code above. \n# Please enter only a number between 0 and 1 inclusive.\n# Please do not remove this comment.\n0.69\n```\n", "meta": {"hexsha": "4941b89aba39c6391efc1c91f4a8c040a6ddf36a", "size": 47431, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hw4_wordentai_with_bakeoff.ipynb", "max_stars_repo_name": "yiyang7/cs224u", "max_stars_repo_head_hexsha": "3e360a15640f3ba5fc24f34ad45fc8284aabd26d", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "hw4_wordentai_with_bakeoff.ipynb", "max_issues_repo_name": "yiyang7/cs224u", "max_issues_repo_head_hexsha": "3e360a15640f3ba5fc24f34ad45fc8284aabd26d", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hw4_wordentai_with_bakeoff.ipynb", "max_forks_repo_name": "yiyang7/cs224u", "max_forks_repo_head_hexsha": "3e360a15640f3ba5fc24f34ad45fc8284aabd26d", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.376109215, "max_line_length": 574, "alphanum_fraction": 0.5261748645, "converted": true, "num_tokens": 8780, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.2751297238231752, "lm_q1q2_score": 0.1375648619115876}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)//2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\n Applied log-transform to lambda_1 and added transformed lambda_1_log_ to model.\n Applied log-transform to lambda_2 and added transformed lambda_2_log_ to model.\n\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000, step=step, return_inferencedata=False)\n```\n\n 100%|██████████| 10000/10000 [00:02<00:00, 4511.50it/s]\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n#type your code here.\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n#type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "abcb724328f2894a5f6e5bf077a3733ccd7d8b07", "size": 369634, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "Study-Repos-Forks/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "efc9398f81f26340d075229f3d2357ce50fd4630", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 19259, "max_stars_repo_stars_event_min_datetime": "2015-01-01T10:31:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T20:15:16.000Z", "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "Study-Repos-Forks/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "efc9398f81f26340d075229f3d2357ce50fd4630", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 255, "max_issues_repo_issues_event_min_datetime": "2015-01-07T17:12:59.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-02T14:13:03.000Z", "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "Study-Repos-Forks/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "efc9398f81f26340d075229f3d2357ce50fd4630", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 7037, "max_forks_repo_forks_event_min_datetime": "2015-01-01T12:58:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T23:01:12.000Z", "avg_line_length": 345.7754911132, "max_line_length": 104444, "alphanum_fraction": 0.9033043497, "converted": true, "num_tokens": 11184, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4416730056646256, "lm_q2_score": 0.3106943768319878, "lm_q1q2_score": 0.13722531925848186}}
{"text": "```python\n%matplotlib inline\n```\n\n# 592B Fall 2019 Problem Set 2 due Thurs 09/19 11.59PM\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport scipy.io.wavfile as wavfile \n\nfrom ipywidgets import interactive\nfrom IPython.display import Audio, display\n```\n\nThe audio file in the directory that this notebook is in, `Fa50.wav`, comes from [Sameer ud Dowla Khan](http://www.reed.edu/linguistics/khan/index.html) at Reed College. It is an utterance of Bengali illustrating how Bengali intonational events chunk utterances into prosodic phrases. See page 101 of Khan's [dissertation on Bengali intonation](http://www.reed.edu/linguistics/khan/assets/Khan%202008%20disseration%20Intonational%20phonology%20and%20focus%20prosody%20of%20Bengali.pdf).\n\nHere's an annotated f0 contour of `Fa50.wav` from that page.\n\n\nYou will be doing some work with this audio file in this problem set.\n\n## Problem 1: converting from samples to time\n\nWrite a function that:\n- plots the audio data from `t_start` to `t_stop`, with time in seconds on the x-axis\n- creates an Audio object you can play, playing the audio data from `t_start` to `t_stop`.\n- if you like, you can generate an interactive \"widget\" like we saw in the Class 2.2 notebook, where you can manipulate sliders and then see the plot and have the audio change.\n\nYou can take a look at the sample code for converting from samples to time in Class 2.2's notebook, but remember that there are problems with that code. You can do way better!\n\n## Problem 2: resampling audio data and writing it to file\n\nThe purpose of this problem is to:\n- introduce you to [`scipy.signal`](https://docs.scipy.org/doc/scipy/reference/signal.html), which we will be continuing to use during the course.\n- have you figure out how to write data to audio files\n- give you experience with figuring out how to use unfamiliar functions own your own\n- get you thinking more about the effect of sampling rates on representing signals\n\n*n.b. in my past experience, people have sometimes had problems using `scipy.signal`'s resampling function on their machine. If that ends up being the case for you, you might try instead [`librosa`](https://librosa.github.io/librosa/)'s sampling function.*\n\n\n1. Resample the bengali audio data using `scipy.signal.resample`, plot the resampled data, and also create a playable Audio object of the resampled data. Do this for two sampling rates: two times the original sampling rate of the file, and half of the original sampling rate of the file. Note: you may need to use `round()` and `int()` to coerce the number of samples to be an integer.\n2. Try to explain why the audio sounds the way it does for the upsampled and downsampled audio.\n3. Write the re-sampled audio to WAV files in the current directory using `scipy.io.wavfile.write`.\n4. Use `scipy.io.wavfile.read` to read in your re-sampled files and check that the sampling rate is what you expect.\n\n\n\n\n\n\n\n## Problem 3: Fourier series of a square wave\n\nWe will be going over the introductory material you need for this on Tuesday 09/17, so feel free to wait until then to get started on this problem if you like.\n\n### Define a square wave.\n1. Define a function for a [square wave](http://mathworld.wolfram.com/SquareWave.html) with a period of 1, with y = 1 from x = 0 to 0.5, and y = 0 from x = 0.5 to 1. You might see if there are any functions in `scipy.signal` that could help.\n2. Make a plot of your square wave showing 5 periods.\n\n### Reconstruct the square wave using a Fourier series.\n1. Calculate the Fourier coefficients for a square wave. Note: there are an infinite number of\ncoefficients, so just calculate the first six. Try to find a\npattern for the coefficient values of the infinite series.\n2. Plot the individual Fourier series terms, i.e., make plots of each of the following:\n\\begin{align}\n a_0\\\\\n a_1\\cos(2\\pi nt) + b_1\\sin(2\\pi nt)\\\\\n a_2\\cos(2\\pi nt) + b_2\\sin(2\\pi nt)\\\\\n a_3\\cos(2\\pi nt) + b_3\\sin(2\\pi nt)\\\\\n a_4\\cos(2\\pi nt) + b_4\\sin(2\\pi nt)\\\\\n a_5\\cos(2\\pi nt) + b_5\\sin(2\\pi nt)\n\\end{align}\n\n3. Plot the reconstruction of the square wave as you add in successive terms in the Fourier series, i.e., make plots of each of the following (I am subsuming $a_0$ as a term in the sum by having the sum start from $n=0$):\n\n\\begin{align}\n \\displaystyle\\sum\\limits_{n=0}^0 \\left(a_n\\cos(2\\pi nt) + b_n\\sin(2\\pi nt)\\right)\\\\\n \\displaystyle\\sum\\limits_{n=0}^1 \\left(a_n\\cos(2\\pi nt) + b_n\\sin(2\\pi nt)\\right)\\\\\n \\displaystyle\\sum\\limits_{n=0}^2 \\left(a_n\\cos(2\\pi nt) + b_n\\sin(2\\pi nt)\\right)\\\\\n \\displaystyle\\sum\\limits_{n=0}^3 \\left(a_n\\cos(2\\pi nt) + b_n\\sin(2\\pi nt)\\right)\\\\\n \\displaystyle\\sum\\limits_{n=0}^4 \\left(a_n\\cos(2\\pi nt) + b_n\\sin(2\\pi nt)\\right)\\\\\n \\displaystyle\\sum\\limits_{n=0}^5 \\left(a_n\\cos(2\\pi nt) + b_n\\sin(2\\pi nt)\\right)\\\\\n\\end{align}\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "88f122693360c40a44b11e0d0f5afaaa0e47b9c1", "size": 6783, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "592B-f19_ps02.ipynb", "max_stars_repo_name": "ling592b-f19/ling592b-f19-ps01-nisayas", "max_stars_repo_head_hexsha": "35ddff036d30cd2aecd2fdb47ec6b4768f890c96", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "592B-f19_ps02.ipynb", "max_issues_repo_name": "ling592b-f19/ling592b-f19-ps01-nisayas", "max_issues_repo_head_hexsha": "35ddff036d30cd2aecd2fdb47ec6b4768f890c96", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "592B-f19_ps02.ipynb", "max_forks_repo_name": "ling592b-f19/ling592b-f19-ps01-nisayas", "max_forks_repo_head_hexsha": "35ddff036d30cd2aecd2fdb47ec6b4768f890c96", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 44.3333333333, "max_line_length": 495, "alphanum_fraction": 0.6208167478, "converted": true, "num_tokens": 1418, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42250463481418826, "lm_q2_score": 0.3242354055108441, "lm_q1q2_score": 0.13699096159918944}}
{"text": "```python\n%matplotlib inline\n```\n\n\n마리오 게임 RL 에이전트로 학습하기\n===============================\n\n저자: `Yuansong Feng `__, `Suraj\nSubramanian `__, `Howard\nWang `__, `Steven\nGuo `__.\n\n번역: `김태영 `__. \n\n이번 튜토리얼에서는 심층 강화 학습의 기본 사항들에 대해 이야기해보도록 하겠습니다.\n마지막에는, 스스로 게임을 할 수 있는 AI 기반 마리오를 \n(`Double Deep Q-Networks `__ 사용) \n구현하게 됩니다.\n\n이 튜토리얼에서는 RL에 대한 사전 지식이 필요하지 않지만, \n이러한 `링크 `__\n를 통해 RL 개념에 친숙해 질 수 있으며,\n여기 있는\n`치트시트 `__\n를 활용할 수도 있습니다. 튜토리얼에서 사용하는 전체 코드는\n`여기 `__\n을 사용합니다. DDQN 두개의 ConvNets ( $Q_{online}$ 과\n$Q_{target}$ ) 을 사용하고, 독립적으로 최적의 행동-가치 함수에 \n근사 시키려고 합니다.\n\n구현을 할 때, 특징 생성기에서 ``특징들`` 을 $Q_{online}$ 와 $Q_{target}$\n에 공유합니다. 그러나 각각의 FC 분류기는\n가지고 있도록 설계합니다. $\\theta_{target}$ ($Q_{target}$\n의 매개변수 값) 는 역전파에 의해 값이 업데이트 되지 않도록 고정되었습니다.\n대신, $\\theta_{online}$ 와 주기적으로 동기화를 진행합니다. \n이것에 대해서는 추후에 다루도록 하겠습니다.)\n\n신경망\n~~~~~~~~~~~~~~~~~~\n\n\n\n\n```python\nclass MarioNet(nn.Module):\n \"\"\"작은 cnn 구조\n 입력 -> (conv2d + relu) x 3 -> flatten -> (dense + relu) x 2 -> 출력\n \"\"\"\n\n def __init__(self, input_dim, output_dim):\n super().__init__()\n c, h, w = input_dim\n\n if h != 84:\n raise ValueError(f\"Expecting input height: 84, got: {h}\")\n if w != 84:\n raise ValueError(f\"Expecting input width: 84, got: {w}\")\n\n self.online = nn.Sequential(\n nn.Conv2d(in_channels=c, out_channels=32, kernel_size=8, stride=4),\n nn.ReLU(),\n nn.Conv2d(in_channels=32, out_channels=64, kernel_size=4, stride=2),\n nn.ReLU(),\n nn.Conv2d(in_channels=64, out_channels=64, kernel_size=3, stride=1),\n nn.ReLU(),\n nn.Flatten(),\n nn.Linear(3136, 512),\n nn.ReLU(),\n nn.Linear(512, output_dim),\n )\n\n self.target = copy.deepcopy(self.online)\n\n # Q_target 매개변수 값은 고정시킵니다.\n for p in self.target.parameters():\n p.requires_grad = False\n\n def forward(self, input, model):\n if model == \"online\":\n return self.online(input)\n elif model == \"target\":\n return self.target(input)\n```\n\nTD 추정 & TD 목표값\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n학습을 하는데 두 가지 값들이 포함됩니다.\n\n**TD 추정** - 주어진 상태 $s$ 에서 최적의 예측 $Q^*$. \n\n\\begin{align}{TD}_e = Q_{online}^*(s,a)\\end{align}\n\n**TD 목표** - 현재의 포상과 다음상태 $s'$ 에서 추정된 $Q^*$ 의 합.\n\n\\begin{align}a' = argmax_{a} Q_{online}(s', a)\\end{align}\n\n\\begin{align}{TD}_t = r + \\gamma Q_{target}^*(s',a')\\end{align}\n\n다음 행동 $a'$ 가 어떨지 모르기 때문에 \n다음 상태 $s'$ 에서 $Q_{online}$ 값이 최대가 되도록 하는\n행동 $a'$ 를 사용합니다.\n\n여기에서 변화도 계산을 비활성화하기 위해\n``td_target()`` 에서 `@torch.no_grad() `__\n데코레이터(decorator)를 사용합니다.\n($\\theta_{target}$ 의 역전파 계산이 필요로 하지 않기 때문입니다.)\n\n\n\n\n\n```python\nclass Mario(Mario):\n def __init__(self, state_dim, action_dim, save_dir):\n super().__init__(state_dim, action_dim, save_dir)\n self.gamma = 0.9\n\n def td_estimate(self, state, action):\n current_Q = self.net(state, model=\"online\")[\n np.arange(0, self.batch_size), action\n ] # Q_online(s,a)\n return current_Q\n\n @torch.no_grad()\n def td_target(self, reward, next_state, done):\n next_state_Q = self.net(next_state, model=\"online\")\n best_action = torch.argmax(next_state_Q, axis=1)\n next_Q = self.net(next_state, model=\"target\")[\n np.arange(0, self.batch_size), best_action\n ]\n return (reward + (1 - done.float()) * self.gamma * next_Q).float()\n```\n\n모델을 업데이트 하기.\n~~~~~~~~~~~~~~~~~~~~~~\n\n마리오가 재생 버퍼에서 입력을 샘플링할 때, $TD_t$\n와 $TD_e$ 를 계산합니다. 그리고 이 손실을 이용하여 $Q_{online}$ 역전파하여\n매개변수 $\\theta_{online}$ 를 업데이트합니다. ($\\alpha$ 는 \n``optimizer`` 에 전달되는 학습률 ``lr`` 입니다.)\n\n\\begin{align}\\theta_{online} \\leftarrow \\theta_{online} + \\alpha \\nabla(TD_e - TD_t)\\end{align}\n\n$\\theta_{target}$ 은 역전파를 통해 업데이트 되지 않습니다.\n대신, 주기적으로 $\\theta_{online}$ 의 값을 $\\theta_{target}$ \n로 복사합니다.\n\n\\begin{align}\\theta_{target} \\leftarrow \\theta_{online}\\end{align}\n\n\n\n\n\n\n```python\nclass Mario(Mario):\n def __init__(self, state_dim, action_dim, save_dir):\n super().__init__(state_dim, action_dim, save_dir)\n self.optimizer = torch.optim.Adam(self.net.parameters(), lr=0.00025)\n self.loss_fn = torch.nn.SmoothL1Loss()\n\n def update_Q_online(self, td_estimate, td_target):\n loss = self.loss_fn(td_estimate, td_target)\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n return loss.item()\n\n def sync_Q_target(self):\n self.net.target.load_state_dict(self.net.online.state_dict())\n```\n\n체크포인트를 저장합니다.\n~~~~~~~~~~~~~~~~~~~~~~~\n\n\n\n\n\n```python\nclass Mario(Mario):\n def save(self):\n save_path = (\n self.save_dir / f\"mario_net_{int(self.curr_step // self.save_every)}.chkpt\"\n )\n torch.save(\n dict(model=self.net.state_dict(), exploration_rate=self.exploration_rate),\n save_path,\n )\n print(f\"MarioNet saved to {save_path} at step {self.curr_step}\")\n```\n\n모든 기능을 종합해봅시다.\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n\n\n\n\n```python\nclass Mario(Mario):\n def __init__(self, state_dim, action_dim, save_dir):\n super().__init__(state_dim, action_dim, save_dir)\n self.burnin = 1e4 # 학습을 진행하기 전 최소한의 경험값.\n self.learn_every = 3 # Q_online 업데이트 사이의 경험 횟수.\n self.sync_every = 1e4 # Q_target과 Q_online sync 사이의 경험 수\n\n def learn(self):\n if self.curr_step % self.sync_every == 0:\n self.sync_Q_target()\n\n if self.curr_step % self.save_every == 0:\n self.save()\n\n if self.curr_step < self.burnin:\n return None, None\n\n if self.curr_step % self.learn_every != 0:\n return None, None\n\n # 메모리로부터 샘플링을 합니다.\n state, next_state, action, reward, done = self.recall()\n\n # TD 추정값을 가져옵니다.\n td_est = self.td_estimate(state, action)\n\n # TD 목표값을 가져옵니다.\n td_tgt = self.td_target(reward, next_state, done)\n\n # 실시간 Q(Q_online)을 통해 역전파 손실을 계산합니다.\n loss = self.update_Q_online(td_est, td_tgt)\n\n return (td_est.mean().item(), loss)\n```\n\n기록하기\n--------------\n\n\n\n\n\n```python\nimport numpy as np\nimport time, datetime\nimport matplotlib.pyplot as plt\n\n\nclass MetricLogger:\n def __init__(self, save_dir):\n self.save_log = save_dir / \"log\"\n with open(self.save_log, \"w\") as f:\n f.write(\n f\"{'Episode':>8}{'Step':>8}{'Epsilon':>10}{'MeanReward':>15}\"\n f\"{'MeanLength':>15}{'MeanLoss':>15}{'MeanQValue':>15}\"\n f\"{'TimeDelta':>15}{'Time':>20}\\n\"\n )\n self.ep_rewards_plot = save_dir / \"reward_plot.jpg\"\n self.ep_lengths_plot = save_dir / \"length_plot.jpg\"\n self.ep_avg_losses_plot = save_dir / \"loss_plot.jpg\"\n self.ep_avg_qs_plot = save_dir / \"q_plot.jpg\"\n\n # 지표(Metric)와 관련된 리스트입니다.\n self.ep_rewards = []\n self.ep_lengths = []\n self.ep_avg_losses = []\n self.ep_avg_qs = []\n\n # 모든 record() 함수를 호출한 후 이동 평균(Moving average)을 계산합니다.\n self.moving_avg_ep_rewards = []\n self.moving_avg_ep_lengths = []\n self.moving_avg_ep_avg_losses = []\n self.moving_avg_ep_avg_qs = []\n\n # 현재 에피스드에 대한 지표를 기록합니다.\n self.init_episode()\n\n # 시간에 대한 기록입니다.\n self.record_time = time.time()\n\n def log_step(self, reward, loss, q):\n self.curr_ep_reward += reward\n self.curr_ep_length += 1\n if loss:\n self.curr_ep_loss += loss\n self.curr_ep_q += q\n self.curr_ep_loss_length += 1\n\n def log_episode(self):\n \"에피스드의 끝을 표시합니다.\"\n self.ep_rewards.append(self.curr_ep_reward)\n self.ep_lengths.append(self.curr_ep_length)\n if self.curr_ep_loss_length == 0:\n ep_avg_loss = 0\n ep_avg_q = 0\n else:\n ep_avg_loss = np.round(self.curr_ep_loss / self.curr_ep_loss_length, 5)\n ep_avg_q = np.round(self.curr_ep_q / self.curr_ep_loss_length, 5)\n self.ep_avg_losses.append(ep_avg_loss)\n self.ep_avg_qs.append(ep_avg_q)\n\n self.init_episode()\n\n def init_episode(self):\n self.curr_ep_reward = 0.0\n self.curr_ep_length = 0\n self.curr_ep_loss = 0.0\n self.curr_ep_q = 0.0\n self.curr_ep_loss_length = 0\n\n def record(self, episode, epsilon, step):\n mean_ep_reward = np.round(np.mean(self.ep_rewards[-100:]), 3)\n mean_ep_length = np.round(np.mean(self.ep_lengths[-100:]), 3)\n mean_ep_loss = np.round(np.mean(self.ep_avg_losses[-100:]), 3)\n mean_ep_q = np.round(np.mean(self.ep_avg_qs[-100:]), 3)\n self.moving_avg_ep_rewards.append(mean_ep_reward)\n self.moving_avg_ep_lengths.append(mean_ep_length)\n self.moving_avg_ep_avg_losses.append(mean_ep_loss)\n self.moving_avg_ep_avg_qs.append(mean_ep_q)\n\n last_record_time = self.record_time\n self.record_time = time.time()\n time_since_last_record = np.round(self.record_time - last_record_time, 3)\n\n print(\n f\"Episode {episode} - \"\n f\"Step {step} - \"\n f\"Epsilon {epsilon} - \"\n f\"Mean Reward {mean_ep_reward} - \"\n f\"Mean Length {mean_ep_length} - \"\n f\"Mean Loss {mean_ep_loss} - \"\n f\"Mean Q Value {mean_ep_q} - \"\n f\"Time Delta {time_since_last_record} - \"\n f\"Time {datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')}\"\n )\n\n with open(self.save_log, \"a\") as f:\n f.write(\n f\"{episode:8d}{step:8d}{epsilon:10.3f}\"\n f\"{mean_ep_reward:15.3f}{mean_ep_length:15.3f}{mean_ep_loss:15.3f}{mean_ep_q:15.3f}\"\n f\"{time_since_last_record:15.3f}\"\n f\"{datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S'):>20}\\n\"\n )\n\n for metric in [\"ep_rewards\", \"ep_lengths\", \"ep_avg_losses\", \"ep_avg_qs\"]:\n plt.plot(getattr(self, f\"moving_avg_{metric}\"))\n plt.savefig(getattr(self, f\"{metric}_plot\"))\n plt.clf()\n```\n\n게임을 실행시켜봅시다!\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n\n이번 예제에서는 10개의 에피소드에 대해 학습 루프를 실행시켰습니다.하지만 마리오가 진정으로 \n세계를 학습하기 위해서는 적어도 40000개의 에피소드에 대해 학습을 시킬 것을 제안합니다!\n\n\n\n\n\n```python\nuse_cuda = torch.cuda.is_available()\nprint(f\"Using CUDA: {use_cuda}\")\nprint()\n\nsave_dir = Path(\"checkpoints\") / datetime.datetime.now().strftime(\"%Y-%m-%dT%H-%M-%S\")\nsave_dir.mkdir(parents=True)\n\nmario = Mario(state_dim=(4, 84, 84), action_dim=env.action_space.n, save_dir=save_dir)\n\nlogger = MetricLogger(save_dir)\n\nepisodes = 10\nfor e in range(episodes):\n\n state = env.reset()\n\n # 게임을 실행시켜봅시다!\n while True:\n\n # 현재 상태에서 에이전트 실행하기\n action = mario.act(state)\n\n # 에이전트가 액션 수행하기\n next_state, reward, done, info = env.step(action)\n\n # 기억하기\n mario.cache(state, next_state, action, reward, done)\n\n # 배우기\n q, loss = mario.learn()\n\n # 기록하기\n logger.log_step(reward, loss, q)\n\n # 상태 업데이트하기\n state = next_state\n\n # 게임이 끝났는지 확인하기\n if done or info[\"flag_get\"]:\n break\n\n logger.log_episode()\n\n if e % 20 == 0:\n logger.record(episode=e, epsilon=mario.exploration_rate, step=mario.curr_step)\n```\n\n결론\n\"\"\"\"\"\"\"\"\"\"\"\"\"\"\"\n\n이 튜토리얼에서는 PyTorch를 사용하여 게임 플레이 AI를 훈련하는 방법을 살펴보았습니다. `OpenAI gym **Bayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.** \n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n # alpha is the hyperparameter that determines the prior distribution of the\n # two lambda variables (i.e. the one before and after the switch point)\n alpha = 1.0/count_data.mean()\n \n # The two lambda parameters. (We want to see if their posterior distributions change)\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n # Tau is the point at which the texting behaviour changed. We don't know anything about this \n # so we assign a uniform prior belief\n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\n /Users/nick/anaconda3/envs/py36/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n from ._conv import register_converters as _register_converters\n\n\n\n```python\ntau\n```\n\n\n\n\n$tau \\sim \\text{DiscreteUniform}(\\mathit{lower}=f(f()), \\mathit{upper}=f(f()))$\n\n\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\n\n```python\nlambda_\n```\n\n\n\n\n Elemwise{switch,no_inplace}.0\n\n\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\n\n```python\nobservation\n```\n\n\n\n\n$obs \\sim \\text{Poisson}(\\mathit{mu}=f(f(f(tau),array),f(lambda\\_1),f(lambda\\_2)))$\n\n\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. **Below, we collect the samples (called *traces* in the MCMC literature) into histograms.**\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n 100%|██████████| 15000/15000 [00:08<00:00, 1773.12it/s]\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nprint(''.join([ \"{} {} {}\\n\".format(x,y,z) for (x,y,z) in zip(tau_samples,lambda_1_samples, lambda_2_samples)]))\n```\n\n \n\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. **In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK!** This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\n\n```python\n\n```\n\n [False False False ... False False False]\n\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\n\nprint(\"Lambda1 mean: {} \\nLambda2 mean: {}\".format(np.mean(lambda_1_samples), np.mean(lambda_2_samples) ) )\n```\n\n Lambda1 mean: 17.75942384685025 \n Lambda2 mean: 22.72799947930949\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\npct = (lambda_2_samples.mean() - lambda_1_samples.mean()) / lambda_1_samples.mean() * 100\nprint(\"Percentage change in text messaging rates: {}\".format(pct))\n```\n\n Percentage change in text messaging rates: 27.97712175409591\n\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\nlambda_1_samples[tau_samples < 45].mean()\n#tau_samples < 45\n```\n\n\n\n\n 17.752720861774307\n\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "30cc1a6c5f8edb9c4661e8332cf62d7b2fe541cb", "size": 304881, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "nickmalleson/ProbabilisticProgramming", "max_stars_repo_head_hexsha": "c2e83f8ce9e38f9850014aeebaab7d9658fa214e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "nickmalleson/ProbabilisticProgramming", "max_issues_repo_head_hexsha": "c2e83f8ce9e38f9850014aeebaab7d9658fa214e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "nickmalleson/ProbabilisticProgramming", "max_forks_repo_head_hexsha": "c2e83f8ce9e38f9850014aeebaab7d9658fa214e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 251.759702725, "max_line_length": 89752, "alphanum_fraction": 0.8973501137, "converted": true, "num_tokens": 11759, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3557748935136304, "lm_q2_score": 0.3849121444839335, "lm_q1q2_score": 0.13694207721587456}}
{"text": "\n\n\n\n\n```\ncoinflips_mean_dist.rvs(100)\n```\n\n\n\n\n array([0.47447628, 0.51541425, 0.54722018, 0.4589882 , 0.51501386,\n 0.53819192, 0.43382292, 0.53546659, 0.47026173, 0.44967562,\n 0.4621107 , 0.42691904, 0.37324325, 0.47531437, 0.46052277,\n 0.48711257, 0.52456771, 0.43332181, 0.49545882, 0.44671454,\n 0.47520117, 0.47047251, 0.41828918, 0.50159477, 0.42965501,\n 0.45273383, 0.48045849, 0.45342529, 0.48238344, 0.53966291,\n 0.48230241, 0.48073422, 0.48553525, 0.47962228, 0.41274185,\n 0.42892633, 0.5170948 , 0.42678096, 0.42249309, 0.51499109,\n 0.47059199, 0.39903942, 0.41790336, 0.46406817, 0.42232382,\n 0.42163269, 0.47848227, 0.48232842, 0.4731858 , 0.51077244,\n 0.3957508 , 0.48504646, 0.49014295, 0.53252732, 0.45495376,\n 0.47883978, 0.60393033, 0.4492549 , 0.44797902, 0.54782121,\n 0.43380002, 0.5760073 , 0.36941266, 0.44467418, 0.4939245 ,\n 0.45278835, 0.55635162, 0.48695459, 0.39080983, 0.45948606,\n 0.2941779 , 0.35950718, 0.44805696, 0.4725126 , 0.42218381,\n 0.45985418, 0.47545393, 0.44317753, 0.46267013, 0.4458753 ,\n 0.44204707, 0.51334913, 0.50914181, 0.49923748, 0.46895674,\n 0.43892798, 0.45984946, 0.44984632, 0.53560791, 0.45865723,\n 0.48646824, 0.55937503, 0.41464303, 0.50701457, 0.46934196,\n 0.37681534, 0.42748113, 0.49812825, 0.48278895, 0.4964763 ])\n\n\n\n## Assignment - Code it up!\n\nMost of the above was pure math - now write Python code to reproduce the results! This is purposefully open ended - you'll have to think about how you should represent probabilities and events. You can and should look things up, and as a stretch goal - refactor your code into helpful reusable functions!\n\nSpecific goals/targets:\n\n1. Write a function `def prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk)` that reproduces the example from lecture, and use it to calculate and visualize a range of situations\n2. Explore `scipy.stats.bayes_mvs` - read its documentation, and experiment with it on data you've tested in other ways earlier this week\n3. Create a visualization comparing the results of a Bayesian approach to a traditional/frequentist approach\n4. In your own words, summarize the difference between Bayesian and Frequentist statistics\n\nIf you're unsure where to start, check out [this blog post of Bayes theorem with Python](https://dataconomy.com/2015/02/introduction-to-bayes-theorem-with-python/) - you could and should create something similar!\n\nStretch goals:\n\n- Apply a Bayesian technique to a problem you previously worked (in an assignment or project work) on from a frequentist (standard) perspective\n- Check out [PyMC3](https://docs.pymc.io/) (note this goes beyond hypothesis tests into modeling) - read the guides and work through some examples\n- Take PyMC3 further - see if you can build something with it!\n\n\n```\ndef prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk):\n return (prob_positive_drunk*prob_drunk_prior)/prob_positive\n```\n\n\n```\n# Reproduction of the example from class\n\nprob_drunk_given_positive(.001,.08,1)\n```\n\n\n\n\n 0.0125\n\n\n\n\n```\n# Create a more generalizable function with the full denominator\n\ndef proba_givenb(probb_givena, proba, probb_givennota):\n num = probb_givena * proba\n prob_nota = 1 - proba\n denom = num + (probb_givennota*prob_nota)\n return num/denom\n```\n\n\n```\n# Sanity check to make sure the new function gets the correct result in the case of \n# the breathalyzer example\n\nproba_givenb(1,.001, .08)\n```\n\n\n\n\n 0.012357884330202669\n\n\n\n\n```\n# Function to recurvsively do multiple tests\n\ndef recursive_proba_givenb(probb_givena, proba, probb_givennota, times_to_run):\n prob = proba_givenb(probb_givena, proba, probb_givennota)\n print('Test 1: ' + str(prob))\n for i in range(1,times_to_run):\n prob = proba_givenb(probb_givena, prob, probb_givennota)\n print('Test ' + str(i+1) + ': ' + str(prob))\n #return prob\n```\n\n\n```\nrecursive_proba_givenb(1,.001, .08, 6)\n```\n\n Test 1: 0.012357884330202669\n Test 2: 0.13525210993291495\n Test 3: 0.6615996951348605\n Test 4: 0.9606895076105054\n Test 5: 0.9967371577896734\n Test 6: 0.9997381867081508\n\n\n\n```\n# Explore scipy.stats.bayes_mvs\n\n# Typing the example code to get a feel for the outputs\n\nfrom scipy import stats\ndata = [6,9,12,7,8,8,13]\nmean, var, std = stats.bayes_mvs(data, alpha=0.95)\nmean\n```\n\n\n\n\n Mean(statistic=9.0, minmax=(6.612058548265569, 11.38794145173443))\n\n\n\n\n```\nvar\n```\n\n\n\n\n Variance(statistic=10.0, minmax=(2.768285761244642, 32.3273011015803))\n\n\n\n\n```\nstd\n```\n\n\n\n\n Std_dev(statistic=2.9724954732045084, minmax=(1.6638166248852793, 5.685710254803731))\n\n\n\n\n```\n# OK. Lets get some data from the adult dataset.\n\nimport pandas as pd\n\ndf = pd.read_csv('https://raw.githubusercontent.com/ryanleeallred/datasets/master/adult.csv', na_values=\" ?\")\nprint(df.shape)\ndf.head(10)\n```\n\n (32561, 15)\n\n\n\n\n\n\n\n
\n \n \n age \n workclass \n fnlwgt \n education \n education-num \n marital-status \n occupation \n relationship \n race \n sex \n capital-gain \n capital-loss \n hours-per-week \n country \n salary \n \n \n \n \n 0 \n 39 \n State-gov \n 77516 \n Bachelors \n 13 \n Never-married \n Adm-clerical \n Not-in-family \n White \n Male \n 2174 \n 0 \n 40 \n United-States \n <=50K \n \n \n 1 \n 50 \n Self-emp-not-inc \n 83311 \n Bachelors \n 13 \n Married-civ-spouse \n Exec-managerial \n Husband \n White \n Male \n 0 \n 0 \n 13 \n United-States \n <=50K \n \n \n 2 \n 38 \n Private \n 215646 \n HS-grad \n 9 \n Divorced \n Handlers-cleaners \n Not-in-family \n White \n Male \n 0 \n 0 \n 40 \n United-States \n <=50K \n \n \n 3 \n 53 \n Private \n 234721 \n 11th \n 7 \n Married-civ-spouse \n Handlers-cleaners \n Husband \n Black \n Male \n 0 \n 0 \n 40 \n United-States \n <=50K \n \n \n 4 \n 28 \n Private \n 338409 \n Bachelors \n 13 \n Married-civ-spouse \n Prof-specialty \n Wife \n Black \n Female \n 0 \n 0 \n 40 \n Cuba \n <=50K \n \n \n 5 \n 37 \n Private \n 284582 \n Masters \n 14 \n Married-civ-spouse \n Exec-managerial \n Wife \n White \n Female \n 0 \n 0 \n 40 \n United-States \n <=50K \n \n \n 6 \n 49 \n Private \n 160187 \n 9th \n 5 \n Married-spouse-absent \n Other-service \n Not-in-family \n Black \n Female \n 0 \n 0 \n 16 \n Jamaica \n <=50K \n \n \n 7 \n 52 \n Self-emp-not-inc \n 209642 \n HS-grad \n 9 \n Married-civ-spouse \n Exec-managerial \n Husband \n White \n Male \n 0 \n 0 \n 45 \n United-States \n >50K \n \n \n 8 \n 31 \n Private \n 45781 \n Masters \n 14 \n Never-married \n Prof-specialty \n Not-in-family \n White \n Female \n 14084 \n 0 \n 50 \n United-States \n >50K \n \n \n 9 \n 42 \n Private \n 159449 \n Bachelors \n 13 \n Married-civ-spouse \n Exec-managerial \n Husband \n White \n Male \n 5178 \n 0 \n 40 \n United-States \n >50K \n \n \n
\n
\n\n
\n \n \n 0 \n 1 \n 2 \n 3 \n 4 \n 5 \n 6 \n 7 \n 8 \n 9 \n 10 \n 11 \n 12 \n 13 \n 14 \n 15 \n 16 \n \n \n \n \n 0 \n republican \n n \n y \n n \n y \n y \n y \n n \n n \n n \n y \n ? \n y \n y \n y \n n \n y \n \n \n 1 \n republican \n n \n y \n n \n y \n y \n y \n n \n n \n n \n n \n n \n y \n y \n y \n n \n ? \n \n \n 2 \n democrat \n ? \n y \n y \n ? \n y \n y \n n \n n \n n \n n \n y \n n \n y \n y \n n \n n \n \n \n 3 \n democrat \n n \n y \n y \n n \n ? \n y \n n \n n \n n \n n \n y \n n \n y \n n \n n \n y \n \n \n 4 \n democrat \n y \n y \n y \n n \n y \n y \n n \n n \n n \n n \n y \n ? \n y \n y \n y \n y \n \n \n
\n
\n\n
\n \n \n Class Name \n handicapped-infants \n water-project-cost-sharing \n adoption-of-the-budget-resolution \n physician-fee-freeze \n el-salvador-aid \n religious-groups-in-schools \n anti-satellite-test-ban \n aid-to-nicaraguan-contras \n mx-missile \n immigration \n synfuels-corporation-cutback \n education-spending \n superfund-right-to-sue \n crime \n duty-free-exports \n export-administration-act-south-africa \n \n \n \n \n 0 \n republican \n 0 \n 1 \n 0 \n 1 \n 1 \n 1 \n 0 \n 0 \n 0 \n 1 \n 0 \n 1 \n 1 \n 1 \n 0 \n 1 \n \n \n 1 \n republican \n 0 \n 1 \n 0 \n 1 \n 1 \n 1 \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n 1 \n 1 \n 0 \n 0 \n \n \n 2 \n democrat \n 0 \n 1 \n 1 \n 0 \n 1 \n 1 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 1 \n 1 \n 0 \n 0 \n \n \n 3 \n democrat \n 0 \n 1 \n 1 \n 0 \n 0 \n 1 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 1 \n 0 \n 0 \n 1 \n \n \n 4 \n democrat \n 1 \n 1 \n 1 \n 0 \n 1 \n 1 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 1 \n 1 \n 1 \n 1 \n \n \n
\n
here .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n\n```\n\n\n\nToggle cell visibility here .\n\n\n## Internal stability\n\nThe concept of stability captures the behaviour of a system state evolution when this is perturbed from an equilibrium condition: stability describes if the state evolution arising after a perturbation from an equilibrium point diverges or not.\n\n### Definition\nGiven a time invariant dynamic system described by the state vector $x(t)\\in \\mathbb{R}^n$, a point of equilibrium $x_e$, an initial state $x_0$ and an initial time $t_0$ if\n$$\n\\forall \\, \\epsilon \\in \\mathbb{R}, \\, \\epsilon > 0 \\quad \\exists \\delta \\in \\mathbb{R}, \\, \\delta > 0 : \\quad ||x_0-x_e|| < \\delta \\, \\Rightarrow \\, ||x(t)-x_e|| < \\epsilon \\quad \\forall t \\ge t_0\n$$\nthat could be read as: if a small enough initial perturbation $\\delta$ from the equilibrium point exists so that the state evolution $x(t)$ from the perturbed point does not get too far (more than $\\epsilon$) from the equilibrium itself, \nthen the equilibrium point is stable. \n\nIf it also happens that $\\lim_{t\\to\\infty}||x(t)-x_e|| = 0$, that can be read as: the state evolution returns back to the equilibrium point, then the equilibrium is said to be asymptotically stable.\n\nIn the case of linear time invariant systems of the type:\n\\begin{cases}\n\\dot{x} = Ax +Bu \\\\\ny = Cx + Du,\n\\end{cases}\n\nit is possible to prove that stability of one equilibrium point implies stability of all equilibrium points, thus we can talk about stability of the system even if, in general, the stability property is related to an equilibrium point. This linear system's peculiar feature is due to the fact that the evolution of this type of systems is strictly related to the eigenvalues of the dynamics matrix $A$, which are rotation-, translation-, initial-condition- and time-invariant.\n\nRecall what is explained in example [Modal Analysis](SS-02-Modal_Analysis.ipynb):\n\n> The closed form solution of the differential equation, from initial time $t_0$, with initial condition $x(t_0)$ is: \n$$\nx(t) = e^{A(t-t_0)}x(t_0).\n$$ The matrix $e^{A(t-t_0)}x(t_0)$ is composed of linear combinations of functions of time $t$, each one of the type: $$e^{\\lambda t},$$ where the $\\lambda$(s) are the eigenvalues of the matrix $A$; these functions are the modes of the system.\n\nthus:\n- a linear dynamic system is stable if and only if all its modes are not divergent,\n- a linear dynamic system is asymptotically stable if and only if all its modes are convergent,\n- a linear dynamic system is unstable if it has at least one divergent mode. \n\nand, with respect to dynamic matrix eigenvalues, these happen if:\n- all the eigenvalues of $A$ belong to the closed left half complex plane (that is they have negative or zero real part) and, in case they have zero real part, their algebraic multiplicity is the same of the geometric multiplicity, or, equivalently, they have scalar blocks in the Jordan form; \n- all the eigenvalues belong to the open left half imaginary plane, that is they have strictly negative real part;\n- at least one eigenvalue has positive real part, or eigenvalues with zero real part and non-scalar Jordan blocks exist.\n\nThis interactive example presents an editable dynamic matrix $A$ and shows the system free response with the corresponding eigenvalues.\n\n### How to use this notebook?\n- Try to change the eigenvalues and the initial condition $x_0$ and see how the response changes.\n\n\n```python\n%matplotlib inline\n#%matplotlib notebook \nimport control as control\nimport numpy\nimport sympy as sym\nfrom IPython.display import display, Markdown\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\n\n\n#print a matrix latex-like\ndef bmatrix(a):\n \"\"\"Returns a LaTeX bmatrix - by Damir Arbula (ICCT project)\n\n :a: numpy array\n :returns: LaTeX bmatrix as a string\n \"\"\"\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{bmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{bmatrix}']\n return '\\n'.join(rv)\n\n\n# Display formatted matrix: \ndef vmatrix(a):\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{vmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{vmatrix}']\n return '\\n'.join(rv)\n\n\n#matrixWidget is a matrix looking widget built with a VBox of HBox(es) that returns a numPy array as value !\nclass matrixWidget(widgets.VBox):\n def updateM(self,change):\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.M_[irow,icol] = self.children[irow].children[icol].value\n #print(self.M_[irow,icol])\n self.value = self.M_\n\n def dummychangecallback(self,change):\n pass\n \n \n def __init__(self,n,m):\n self.n = n\n self.m = m\n self.M_ = numpy.matrix(numpy.zeros((self.n,self.m)))\n self.value = self.M_\n widgets.VBox.__init__(self,\n children = [\n widgets.HBox(children = \n [widgets.FloatText(value=0.0, layout=widgets.Layout(width='90px')) for i in range(m)]\n ) \n for j in range(n)\n ])\n \n #fill in widgets and tell interact to call updateM each time a children changes value\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n self.children[irow].children[icol].observe(self.updateM, names='value')\n #value = Unicode('example@example.com', help=\"The email value.\").tag(sync=True)\n self.observe(self.updateM, names='value', type= 'All')\n \n def setM(self, newM):\n #disable callbacks, change values, and reenable\n self.unobserve(self.updateM, names='value', type= 'All')\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].unobserve(self.updateM, names='value')\n self.M_ = newM\n self.value = self.M_\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].observe(self.updateM, names='value')\n self.observe(self.updateM, names='value', type= 'All') \n\n #self.children[irow].children[icol].observe(self.updateM, names='value')\n\n \n#overlaod class for state space systems that DO NOT remove \"useless\" states (what \"professor\" of automatic control would do this?)\nclass sss(control.StateSpace):\n def __init__(self,*args):\n #call base class init constructor\n control.StateSpace.__init__(self,*args)\n #disable function below in base class\n def _remove_useless_states(self):\n pass\n```\n\n\n```python\n# Preparatory cell\n\nA = numpy.matrix([[0,1],[-2/5,-1/5]])\nX0 = numpy.matrix('5; 3')\n\nAw = matrixWidget(2,2)\nAw.setM(A)\nX0w = matrixWidget(2,1)\nX0w.setM(X0)\n```\n\n\n```python\n# Misc\n\n#create dummy widget \nDW = widgets.FloatText(layout=widgets.Layout(width='0px', height='0px'))\n\n#create button widget\nSTART = widgets.Button(\n description='Test',\n disabled=False,\n button_style='', # 'success', 'info', 'warning', 'danger' or ''\n tooltip='Test',\n icon='check'\n)\n \ndef on_start_button_clicked(b):\n #This is a workaround to have intreactive_output call the callback:\n # force the value of the dummy widget to change\n if DW.value> 0 :\n DW.value = -1\n else: \n DW.value = 1\n pass\nSTART.on_click(on_start_button_clicked)\n```\n\n\n```python\n# Main cell\n\ndef main_callback(A, X0, DW):\n sols = numpy.linalg.eig(A)\n sys = sss(A,[[1],[0]],[0,1],0)\n pole = control.pole(sys)\n if numpy.real(pole[0]) != 0:\n p1r = abs(numpy.real(pole[0]))\n else:\n p1r = 1\n if numpy.real(pole[1]) != 0:\n p2r = abs(numpy.real(pole[1]))\n else:\n p2r = 1\n if numpy.imag(pole[0]) != 0:\n p1i = abs(numpy.imag(pole[0]))\n else:\n p1i = 1\n if numpy.imag(pole[1]) != 0:\n p2i = abs(numpy.imag(pole[1]))\n else:\n p2i = 1\n \n print('A\\'s eigenvalues are:',round(sols[0][0],4),'and',round(sols[0][1],4))\n \n #T = numpy.linspace(0, 60, 1000)\n T, yout, xout = control.initial_response(sys,X0=X0,return_x=True)\n \n fig = plt.figure(\"A's eigenvalues\", figsize=(16,16))\n ax = fig.add_subplot(311,title='Poles (Real vs Imag)')\n #plt.axis(True)\n # Move left y-axis and bottim x-axis to centre, passing through (0,0)\n # Eliminate upper and right axes\n ax.spines['left'].set_position(('data',0.0))\n ax.spines['bottom'].set_position(('data',0.0))\n ax.spines['right'].set_color('none')\n ax.spines['top'].set_color('none')\n ax.set_xlim(-max([p1r+p1r/3,p2r+p2r/3]),\n max([p1r+p1r/3,p2r+p2r/3]))\n ax.set_ylim(-max([p1i+p1i/3,p2i+p2i/3]),\n max([p1i+p1i/3,p2i+p2i/3]))\n \n plt.plot([numpy.real(pole[0]),numpy.real(pole[1])],[numpy.imag(pole[0]),numpy.imag(pole[1])],'o')\n plt.grid()\n\n ax1 = fig.add_subplot(312,title='Free response')\n plt.plot(T,xout[0])\n plt.grid()\n ax1.set_xlabel('time [s]')\n ax1.set_ylabel('$x_1$')\n ax1.axvline(x=0,color='black',linewidth='0.8')\n ax1.axhline(y=0,color='black',linewidth='0.8')\n ax2 = fig.add_subplot(313)\n plt.plot(T,xout[1])\n plt.grid()\n ax2.set_xlabel('time [s]')\n ax2.set_ylabel('$x_2$')\n ax2.axvline(x=0,color='black',linewidth='0.8')\n ax2.axhline(y=0,color='black',linewidth='0.8')\n \n #plt.show()\n \n\n \nalltogether = widgets.HBox([widgets.VBox([widgets.Label('$A$:',border=3),\n Aw]),\n widgets.Label(' ',border=3),\n widgets.VBox([widgets.Label('$X_0$:',border=3),\n X0w]),\n START])\nout = widgets.interactive_output(main_callback, {'A':Aw, 'X0':X0w, 'DW':DW})\nout.layout.height = '1000px'\ndisplay(out, alltogether)\n```\n\n\n Output(layout=Layout(height='1000px'))\n\n\n\n HBox(children=(VBox(children=(Label(value='$A$:'), matrixWidget(children=(HBox(children=(FloatText(value=0.0, …\n\n", "meta": {"hexsha": "98db9f20771eb7ae4930348bb89d29a0b6db2472", "size": 16045, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_en/examples/04/.ipynb_checkpoints/SS-17-Internal_stability-checkpoint.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_en/examples/04/SS-17-Internal_stability.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_en/examples/04/SS-17-Internal_stability.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 40.0124688279, "max_line_length": 485, "alphanum_fraction": 0.5237768775, "converted": true, "num_tokens": 2973, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.27512971787959806, "lm_q1q2_score": 0.13649015534414352}}
{"text": "```python\n%autosave 0\n```\n\n# MCPC rehearsal problem Oct 25 2017 at UCSY\n\n## Problem E: Stacking Plates\n\n### Input format\n\n- 1st Line: 1 integer, Number of Test Case, each Test Case has following data\n + 1 Line: 1 integer, **n**(Number of Stacks)\n + **n** Lines: first integer: **h** (Number of Plates), and **h** integers (Plate size)\n \n\n### Output format\n\nCase: (test case number): Number of Operations\n\n\n### Sample Input\n\n```\n3\n2\n3 1 2 4\n2 3 5\n3\n4 1 1 1 1\n4 1 1 1 1\n4 1 1 1 1\n2\n15 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3\n15 1 1 1 1 1 2 2 2 2 2 3 3 3 3 3\n```\n\n\n### Sample Output\n\n```\nCase 1:5\nCase 2:2\nCase 3:5\n```\n\n### Explanation of sample I/O\n\n- 3 test cases\n + Stack of (1,2,4) and (3,5)\n + Stack of 3 (1,1,1,1)\n + Stack of 2 (1,1,1,1,1,2,2,2,2,2,3,3,3,3,3)\n \n- 1st case:\nSplit between 2 and 4, 3 and 5, Move 4 on 5, 3 on 4, (1,2) on 3 ==> Total 5 operations\n\n- 2nd case:\nMove 1st stack (1,1,1,1,1) on 2nd stack, move (1st+2nd stack) on 3rd stack ==> Total 2 operations\n\n- 3rd case:\nSplit between 1 and 2 of 1st stack, between 2 and 3 of 2nd stack, move (2,2,2,2,2,3,3,3,3,3) of 1st stack on (3,3,3,3,3) of 2nd, move (1,1,1,1,1,2,2,2,2,2) of 2nd stack on it, move (1,1,1,1,1) on top ==> Total 5 operations\n\n### Specific vs Abstract, Find a General Rule from Detail\n\nWhen solving problems and puzzles that you can not find how to solve, thinking specificlly then abstractly is important. Finding general rules from specific examples give you a path to the answer.\n\n- Think about simple cases\n- Find general pattern (idea, rule) from there\n- Proove the rule (if possible)\n- Extend the rule to more complex cases\n\n### How to calculate number of operation(movement)\n\nIf there are N stacks and each contains just 1 piece (Split is not necessary), (N-1) operations are reuired. (N-1) is a minimum number of oprations.\n\nFor each Split operation, Join operation is required to create single stack. Total number of operation increases by 2 for each Split operations (S). The order of Split and Join does not affect total number of movement. (Split-Split-Join-Join) = (Split-Join-Split-Join) \\begin{equation} Nmber Of Movement = 2S + (N-1) \\end{equation}\n\nSame size of pieces in original stacks (Case 2 and Case 3) can be considered to be same as single piece. Case 2: 3 stack of (1), Case 3: 2 stack of (1,2,3)\n\n### Optimized movement\n\nReverse-Thinking is sometimes very effective. Create Final Stack and check the boundary. If the combination of the boundary exists in original stacks, it can be used (not necessary to split). **Stack ID needs to be checked, as for detail see later**.\n\n$S = (Maximum Number Of Split) - (Number Of Reused Boundary)$\n\n- Case 1: [1,2,3,4,5] is final form. Boundary of [1,2] exist in Original Stack-1, $S=(2+1)-1=2, Movement=2*2+(2-1)=5$\n- Case 2: Convert original stacks to [1], $Movement=2*0+(3-1)=2$\n- Case 3: Convert original stacks to [1,2,3], Final form is [1,1,2,2,3,3]. Boundary of [1,2] and [2,3] exists. $S=(2+2)-2=2$\n\n### Sample I/O gives hint\n\nSample Input/Output often gives great hint to solve problems. Same number in original stack cause problem in above idea, but same number can be considered to be 1 digit, so convert input data to eliminate duplicate number.\n\n### Stack ID checking\n\n- Assign stack ID\n- Merge every plates and sort by radius (size of plate)\n- Manage the list of candidate for boundary reuse (top and bottom)\n- Boundary assignment can be done greedy, if there is only 1 combination between top of stack and next, use it\n\n\n\n```python\n#!/usr/bin/python3\n# -*- coding: utf-8 -*-\n\n'''\n 2017 MCPC at UCSY\n Problem-E: Stacking Plates\n'''\nimport sys\n\n\nclass TestCase():\n pass\n\n\nclass Plates():\n # Groupt of same radius plates in merged stack\n # id_list: list of stack ID\n def __init__(self, radius, id_list):\n self.radius = radius\n self.id_list = id_list\n self.top = None\n self.bottom = None\n\n def match_prev(self, prev_bottom):\n self.top = list()\n for stack_id in self.id_list:\n if stack_id in prev_bottom:\n self.top.append(stack_id)\n self.bottom = self.id_list.copy()\n if len(self.top) == 1 and len(self.bottom) != 1:\n self.bottom.remove(self.top[0])\n\n return\n\n def __repr__(self):\n return ('Plates {}: {}, top: {} bottom: {}'.format(self.radius, self.id_list, self.top, self.bottom))\n\n\ndef parse_tc(tc):\n '''\n Input: Test Case\n Update: \n Return: None\n '''\n\n tc.n = int(tc.stdin.readline())\n tc.stacks = list()\n\n for i in range(tc.n):\n stack = tc.stdin.readline().split()[1:] # 2d List, 1st=len\n tc.stacks.append(stack)\n\n return\n\n\ndef reform_stack(org):\n '''\n Input: tc.stacks\n Output: cosolidated stacks (no prefix, no duplicate)\n '''\n\n stacks = list()\n stack_id = 0\n\n for stack in org:\n prev_radius = None\n new_stack = list()\n\n for radius in stack:\n if radius != prev_radius:\n new_stack.append((radius, stack_id))\n prev_radius = radius\n\n stacks.append(new_stack)\n stack_id += 1\n\n return stacks\n\n\ndef merge(stacks):\n '''\n stacks: 2D List of tuple(radius, id)\n Return: 1D sorted List\n '''\n\n merged_stack = list()\n\n for stack in stacks:\n merged_stack.extend(stack)\n\n merged_stack.sort()\n\n return merged_stack\n\n\ndef stack2plates(merged_stack):\n '''\n merged_stack: List of Tuple(radius, id)\n return: List of Plates\n '''\n\n plates_list = list()\n id_list = list()\n prev_size = None\n\n for plate in merged_stack:\n radius, plate_id = plate\n if radius != prev_size:\n if id_list:\n plates_list.append(Plates(prev_size, id_list))\n id_list = [plate_id]\n else:\n id_list.append(plate_id)\n\n prev_size = radius\n\n if id_list:\n plates_list.append(Plates(radius, id_list))\n\n return plates_list\n\n\ndef max_reuse(plates_list):\n\n reuse = 0\n prev_bottom = list()\n\n for plates in plates_list:\n plates.match_prev(prev_bottom)\n if plates.top: reuse += 1\n prev_bottom = plates.bottom\n #print(plates, file=sys.stderr)\n\n return reuse\n\ndef solve(tc):\n '''\n Input: Test Case\n Return: Numper of movement\n '''\n\n parse_tc(tc)\n stacks = reform_stack(tc.stacks)\n #print(stacks)\n num_merge = len(stacks) - 1 ## Join Stacks\n for stack in stacks:\n num_merge += (len(stack) - 1) * 2 ## Split and Join\n\n merged_stack = merge(stacks)\n plates_list = stack2plates(merged_stack) # list of Plates\n\n #return (num_merge - check_bound(merged_stack, stack_bound) * 2)\n return (num_merge - max_reuse(plates_list) * 2)\n\n```\n\n\n```python\n### Main routine\n\ninfile = open('reh_e.in', 'r')\n\ntc = TestCase()\ntc.stdin = infile\ntc.t = int(tc.stdin.readline())\n\nfor i in range(tc.t):\n print('Case {}:{}'.format(i+1, solve(tc)))\n```\n\n Case 1:5\n Case 2:2\n Case 3:5\n Case 4:8\n Case 5:3\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "d0ad7ceab923c198077337d18b800ed646b47c90", "size": 10729, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MCPC-Rehearsal-E.ipynb", "max_stars_repo_name": "ShinjiKatoA16/mcpc2017ucsy", "max_stars_repo_head_hexsha": "7f6fbfbb2b05a34c58d30519874b4ca5d0232b94", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "MCPC-Rehearsal-E.ipynb", "max_issues_repo_name": "ShinjiKatoA16/mcpc2017ucsy", "max_issues_repo_head_hexsha": "7f6fbfbb2b05a34c58d30519874b4ca5d0232b94", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "MCPC-Rehearsal-E.ipynb", "max_forks_repo_name": "ShinjiKatoA16/mcpc2017ucsy", "max_forks_repo_head_hexsha": "7f6fbfbb2b05a34c58d30519874b4ca5d0232b94", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.969273743, "max_line_length": 342, "alphanum_fraction": 0.5008854506, "converted": true, "num_tokens": 2101, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4610167793123159, "lm_q2_score": 0.2942149783515163, "lm_q1q2_score": 0.13563804174505878}}
{"text": "+ This notebook is part of lecture 10 *The four fundamental subspaces* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n+ Created by me, Dr Juan H Klopper\n + Head of Acute Care Surgery\n + Groote Schuur Hospital\n + University Cape Town\n + Email me with your thoughts, comments, suggestions and corrections \nLinear Algebra OCW MIT18.06 IPython notebook [2] study notes by Dr Juan H Klopper is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License .\n\n+ [1] OCW MIT 18.06 \n+ [2] Fernando Pérez, Brian E. Granger, IPython: A System for Interactive Scientific Computing, Computing in Science and Engineering, vol. 9, no. 3, pp. 21-29, May/June 2007, doi:10.1109/MCSE.2007.53. URL: http://ipython.org\n\n\n```python\nfrom IPython.core.display import HTML, Image\ncss_file = 'style.css'\nHTML(open(css_file, 'r').read())\n```\n\n\n\n\nT , C(AT )\n* Nullspace of AT , N(AT ) (the left nullspace of A)\n\n## Where are these spaces for a matrix Am×n ?\n\n* C(A) is in ℝm \n* N(A) is in ℝn \n* C(AT ) is in ℝn \n* N(AT ) is in ℝm \n\n## Calculating basis and dimension\n\n### For C(A)\n\n* The bases are the pivot columns\n* The dimension is the rank *r*\n\n### For N(A)\n\n* The bases are the special solutions (one for every free variable, *n* - *r*)\n* The dimension is *n* - *r*\n\n### For C(AT )\n\n* If A undergoes row reduction to row echelon form (R), then C(R) ≠ C(A), but rowspace(R) = rowspace(A) (or C(RT ) = C(AT ))\n* A basis for the rowspace of A (or R) is the first *r* rows of R\n * So we row reduce A and take the pivot rows and transpose them\n* The dimension is also equal to the rank *r*\n\n### For N(AT )\n\n* It is also called the left, because it ends up on the left (as seen below)\n* Here we have AT **y** = **0**\n * **y**T (AT )T = **0**T \n * **y**T A = **0**T \n * This is (again) the pivot columns of AT (after row reduction)\n* The dimension is *m* - *r*\n\n## Example problems\n\n### Consider this example matrix and calculate the bases and dimension for all four fundamental spaces\n\n\n```python\nA = Matrix([[1, 2, 3, 1], [1, 1, 2, 1], [1, 2, 3, 1]]) # We note that rows 1 and three are identical and that\n# columns 3 is the addtion of columns 1 and 2 and column 1 equals column 4\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 2 & 3 & 1\\\\1 & 1 & 2 & 1\\\\1 & 2 & 3 & 1\\end{matrix}\\right]$$\n\n\n\n#### Columnspace\n\n\n```python\nA.rref() # Remember that the columnspace contains the pivot columns as a basis\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & 1 & 1\\\\0 & 1 & 1 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* The basis is thus:\n$$ \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\\\ 0 & 0 \\end{bmatrix} $$\n* It is indeed in ℝ3 (rows of A = *m* = 3, i.e. each column vector is in 3-space or has 3 components)\n\n* The rank (no of columns with pivots) are 2, thus dim(A) = 2\n\n#### Nullspace\n\n\n```python\nA.nullspace() # Calculating the nullspace vectors\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-1\\\\1\\\\0\\end{matrix}\\right], & \\left[\\begin{matrix}-1\\\\0\\\\0\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n* So, indeed the basis is in ℝ4 (A has *n* = 4 columns)\n\n\n```python\nA.rref() # No pivots for columns 3 and 4\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & 1 & 1\\\\0 & 1 & 1 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* The dimension is two (there are 2 column vectors, which is indeed *n* - *r* = 4 - 2 = 2)\n\n#### Rowspace C(AT )\n\n* So we are looking for the pivot columns of AT \n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & 1 & 1\\\\0 & 1 & 1 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* The pivot rows are rows 1 and 2\n* We take them and transpose them\n$$ \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\\\ 1 & 1 \\\\ 1 & 0 \\end{bmatrix} $$\n\n* As stated above, it is in ℝ4 \n\n* The dimension is *n* - *r* = 4 - 2 = 2\n\n#### Nullspace of AT \n\n\n```python\nA.nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-1\\\\1\\\\0\\end{matrix}\\right], & \\left[\\begin{matrix}-1\\\\0\\\\0\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n* Which is indeed in ℝ3 \n\n* The dimension is 1, since *m* - *r* = 3 - 2 = 1 (remember that the rank is the number of pivot columns)\n\n### Consider this example matrix (in LU form) and calculate the bases and dimension for all four fundamental spaces\n\n\n```python\nL = Matrix([[1, 0, 0], [2, 1, 0], [-1, 0, 1]])\nU = Matrix([[5, 0, 3], [0, 1, 1], [0, 0, 0]])\nA = L * U\nL, U, A\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & 0\\\\2 & 1 & 0\\\\-1 & 0 & 1\\end{matrix}\\right], & \\left[\\begin{matrix}5 & 0 & 3\\\\0 & 1 & 1\\\\0 & 0 & 0\\end{matrix}\\right], & \\left[\\begin{matrix}5 & 0 & 3\\\\10 & 1 & 7\\\\-5 & 0 & -3\\end{matrix}\\right]\\end{pmatrix}$$\n\n\n\n#### Columnspace of A\n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & \\frac{3}{5}\\\\0 & 1 & 1\\\\0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* The basis is thus:\n$$ \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\\\ 0 & 0 \\end{bmatrix} $$\n* Another basis would be the pivot columns of L:\n$$ \\begin{bmatrix} 1 & 0 \\\\ 2 & 1 \\\\ -1 & 0 \\end{bmatrix} $$\n* It is in ℝ3 , since *m* = 3\n* It has a rank of 2 (two pivot columns)\n* Since the dimension of the columnspace is equal to the rank, dim(A) = 2\n * Note that it is also equal to the number of pivot columns in U\n\n#### Nullspace of A\n\n\n```python\nA.nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}- \\frac{3}{5}\\\\-1\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n* The nullspace is in ℝ3 , since *n* = 3\n* The basis is the special solution(s), which is one column vector for every free variable\n * Since we only have a single free variable, we have a single nullspace column vector\n * This fits in with the fact that it needs to be *n* - *r*\n * It can also be calculated by taking U, setting the free variable to 1 and solving for the other rows by setting each equal to zero\n* The dimension of the nullspace is also 1 (*n* - *r*, i.e. a single column)\n * It is also the number of free variables\n\n#### The rowspace\n\n* This is the columnspace of AT \n* Don't take the transpose first!\n* Row reduce, identify the rows with pivots and transpose them\n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & \\frac{3}{5}\\\\0 & 1 & 1\\\\0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* The basis is can also be written down by identifying the rows with pivots in U and writing them down as columns (getting their transpose)\n$$ \\begin{bmatrix} 5 & 0 \\\\ 0 & 1 \\\\ 3 & 1 \\end{bmatrix} $$\n* It is in ℝ3 , since *n* = 3\n* The rank *r* = 2, which is equal to the dimension, i.e. dim(AT ) = 2\n\n#### The nullspace of AT \n\n\n```python\nA.transpose().nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}1\\\\0\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n* It is indeed in ℝ3 , since *m* = 3\n* A good way to do it is to take the inverse of L, such that L-1 A = U\n * Now the free variable row in U is row three\n * Take the corresponding row in L-1 and transpose it\n* The dimension in *m* - 2 = 3 - 2 = 1\n\n## The matrix space\n\n* A square matrix is also a 'vector' space, because they obey the vector space rules of addition and scalar multiplication\n* Subspaces (of same) would include\n * Upper triangular matrices\n * Symmetric matrices\n\n\n```python\n\n```\n", "meta": {"hexsha": "61708a405aec9eeff6b0e0827718f3d3fdb3dd6f", "size": 22751, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/I_11_Subspaces.ipynb", "max_stars_repo_name": "solomonxie/jupyter-notebooks", "max_stars_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-13T05:52:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T09:52:35.000Z", "max_issues_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/I_11_Subspaces.ipynb", "max_issues_repo_name": "solomonxie/jupyter-notebooks", "max_issues_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/I_11_Subspaces.ipynb", "max_forks_repo_name": "solomonxie/jupyter-notebooks", "max_forks_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.829009434, "max_line_length": 708, "alphanum_fraction": 0.4738692805, "converted": true, "num_tokens": 3674, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.28140560140262283, "lm_q1q2_score": 0.13520939135720847}}
{"text": "```python\nfrom IPython.core.display import display_html\nfrom urllib.request import urlopen\n\ncssurl = 'http://j.mp/1DnuN9M'\ndisplay_html(urlopen(cssurl).read(), raw=True)\n```\n\n\novdje .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n```\n\n\n\nPromijeni vidljivost ovdje .\n\n\n\n```python\n# Examples: \n# Factored form: 1/(x**2*(x**2 + 1))\n# Expanded form: 1/(x**4+x**2)\n\nimport sympy as sym\nfrom IPython.display import Latex, display, Markdown, Javascript, clear_output\nfrom ipywidgets import widgets, Layout # Interactivity module\n```\n\n## Rastav na parcijalne razlomke\n\nKada se Laplaceova transformacija koristi za analizu sustava, Laplaceova transformacija izlaznog signala dobiva se u obliku umnoška prijenosne funkcije i Laplaceove transformacije ulaznog signala. Rezultat ovog množenja često je složen za shvatiti. Da bismo izvršili inverznu Laplaceovu transformaciju, prvo se izvodi postupak rastava na parcijalne razlomke. Ovaj primjer demonstrira taj postupak.\n\n---\n\n### Kako koristiti ovaj interaktivni primjer?\nIzaberite jednu između ponuđenih opcija: *Unos funkcije* ili *Unos koeficijenata polinoma*.\n\n1. *Unos funkcije*:\n * Primjer: Za unos funkcije $\\frac{1}{x^2(x^2 + 1)}$ (faktorizirani oblik) upišite 1/(x\\*\\*2\\*(x\\*\\*2 + 1)); za unos iste funkcije u proširenom obliku ($\\frac{1}{x^4+x^2}$) upišite 1/(x\\*\\*4+x\\*\\*2).\n\n2. *Unos koeficijenata polinoma*:\n * Pomoću klizača odaberite red brojnika i nazivnika željene funkcije.\n * Upišite koeficijente za brojnik i nazivnik u odgovarajuća unosna polja te kliknite na *Potvrdi*.\n\n\n```python\n## System selector buttons\nstyle = {'description_width': 'initial'}\ntypeSelect = widgets.ToggleButtons(\n options=[('Unos funkcije', 0), ('Unos koeficijenata polinoma', 1),],\n description='Odaberi: ',style={'button_width':'230px'})\n\nbtnReset=widgets.Button(description=\"Reset\")\n\n# function\ntextbox=widgets.Text(description=('Unos funkcije:'),style=style)\nbtnConfirmFunc=widgets.Button(description=\"Potvrdi\") # ex btnConfirm\n\n# poly\nbtnConfirmPoly=widgets.Button(description=\"Potvrdi\") # ex btn\n\ndisplay(typeSelect)\n\ndef on_button_clickedReset(ev):\n display(Javascript(\"Jupyter.notebook.execute_cells_below()\"))\n\ndef on_button_clickedFunc(ev):\n eq = sym.sympify(textbox.value)\n\n if eq==sym.factor(eq):\n display(Markdown('Ulazna funkcija $%s$ je zapisana u faktoriziranom obliku. ' %sym.latex(eq) + 'Njezina proširena verzija je $%s$.' %sym.latex(sym.expand(eq))))\n \n else:\n display(Markdown('Ulazna funkcija $%s$ je zapisana u proširenom obliku. ' %sym.latex(eq) + 'Njezin faktorizirani oblik je $%s$.' %sym.latex(sym.factor(eq))))\n \n display(Markdown('Rezultat rastava na parcijalne razlomke: $%s$' %sym.latex(sym.apart(eq)) + '.'))\n display(btnReset)\n \ndef transfer_function(num,denom):\n num = np.array(num, dtype=np.float64)\n denom = np.array(denom, dtype=np.float64)\n len_dif = len(denom) - len(num)\n if len_dif<0:\n temp = np.zeros(abs(len_dif))\n denom = np.concatenate((temp, denom))\n transferf = np.vstack((num, denom))\n elif len_dif>0:\n temp = np.zeros(len_dif)\n num = np.concatenate((temp, num))\n transferf = np.vstack((num, denom))\n return transferf\n\ndef f(orderNum, orderDenom):\n global text1, text2\n text1=[None]*(int(orderNum)+1)\n text2=[None]*(int(orderDenom)+1)\n display(Markdown('2. Upišite koeficijente za brojnik.'))\n for i in range(orderNum+1):\n text1[i]=widgets.Text(description=(r'a%i'%(orderNum-i)))\n display(text1[i])\n display(Markdown('3. Upišite koeficijente za nazivnik.')) \n for j in range(orderDenom+1):\n text2[j]=widgets.Text(description=(r'b%i'%(orderDenom-j)))\n display(text2[j])\n global orderNum1, orderDenom1\n orderNum1=orderNum\n orderDenom1=orderDenom\n\ndef on_button_clickedPoly(btn):\n clear_output()\n global num,denom\n enacbaNum=\"\"\n enacbaDenom=\"\"\n num=[None]*(int(orderNum1)+1)\n denom=[None]*(int(orderDenom1)+1)\n for i in range(int(orderNum1)+1):\n if text1[i].value=='' or text1[i].value=='Upišite koeficijent':\n text1[i].value='Upišite koeficijent'\n else:\n try:\n num[i]=int(text1[i].value)\n except ValueError:\n if text1[i].value!='' or text1[i].value!='Upišite koeficijent':\n num[i]=sym.var(text1[i].value)\n \n for i in range (len(num)-1,-1,-1):\n if i==0:\n enacbaNum=enacbaNum+str(num[len(num)-i-1])\n elif i==1:\n enacbaNum=enacbaNum+\"+\"+str(num[len(num)-i-1])+\"*x+\"\n elif i==int(len(num)-1):\n enacbaNum=enacbaNum+str(num[0])+\"*x**\"+str(len(num)-1)\n else:\n enacbaNum=enacbaNum+\"+\"+str(num[len(num)-i-1])+\"*x**\"+str(i) \n \n for j in range(int(orderDenom1)+1):\n if text2[j].value=='' or text2[j].value=='Upišite koeficijent':\n text2[j].value='Upišite koeficijent'\n else:\n try:\n denom[j]=int(text2[j].value)\n except ValueError:\n if text2[j].value!='' or text2[j].value!='Upišite koeficijent':\n denom[j]=sym.var(text2[j].value)\n \n for i in range (len(denom)-1,-1,-1):\n if i==0:\n enacbaDenom=enacbaDenom+\"+\"+str(denom[len(denom)-i-1])\n elif i==1:\n enacbaDenom=enacbaDenom+\"+\"+str(denom[len(denom)-i-1])+\"*x\"\n elif i==int(len(denom)-1):\n enacbaDenom=enacbaDenom+str(denom[0])+\"*x**\"+str(len(denom)-1)\n else:\n enacbaDenom=enacbaDenom+\"+\"+str(denom[len(denom)-i-1])+\"*x**\"+str(i)\n \n funcSym=sym.sympify('('+enacbaNum+')/('+enacbaDenom+')')\n\n DenomSym=sym.sympify(enacbaDenom)\n NumSym=sym.sympify(enacbaNum)\n DenomSymFact=sym.factor(DenomSym);\n funcFactSym=NumSym/DenomSymFact;\n \n if DenomSym==sym.expand(enacbaDenom):\n if DenomSym==DenomSymFact:\n display(Markdown('Zadana funkcija je: $%s$. Brojnik se ne može faktorizirati.' %sym.latex(funcSym)))\n else:\n display(Markdown('Zadana funkcija je: $%s$. Brojnik se ne može faktorizirati. Ista funkcija s faktoriziranim nazivnikom može se zapisati kao: $%s$.' %(sym.latex(funcSym), sym.latex(funcFactSym))))\n\n if sym.apart(funcSym)==funcSym:\n display(Markdown('Nemoguće je napraviti rastav na parcijalne razlomke.'))\n else:\n display(Markdown('Rezultat rastava na parcijalne razlomke je: $%s$' %sym.latex(sym.apart(funcSym)) + '.'))\n \n btnReset.on_click(on_button_clickedReset)\n display(btnReset)\n \ndef partial_frac(index):\n\n if index==0:\n x = sym.Symbol('x') \n display(widgets.HBox((textbox, btnConfirmFunc)))\n btnConfirmFunc.on_click(on_button_clickedFunc)\n btnReset.on_click(on_button_clickedReset)\n \n elif index==1:\n display(Markdown('1. Definirajte red brojnika (orderNum) i nazivnika (orderDenom).'))\n widgets.interact(f, orderNum=widgets.IntSlider(min=0,max=10,step=1,value=0),\n orderDenom=widgets.IntSlider(min=0,max=10,step=1,value=0));\n btnConfirmPoly.on_click(on_button_clickedPoly)\n display(btnConfirmPoly) \n\ninput_data=widgets.interactive_output(partial_frac,{'index':typeSelect})\ndisplay(input_data)\n```\n\n\n ToggleButtons(description='Odaberi: ', options=(('Unos funkcije', 0), ('Unos koeficijenata polinoma', 1)), sty…\n\n\n\n Output()\n\n", "meta": {"hexsha": "919467a484d0b19a2b8c2841966ae61ec7926800", "size": 11622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-09-Rastav_na_parcijalne_razlomke-checkpoint.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-09-Rastav_na_parcijalne_razlomke-checkpoint.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-09-Rastav_na_parcijalne_razlomke-checkpoint.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 37.7337662338, "max_line_length": 406, "alphanum_fraction": 0.5311478231, "converted": true, "num_tokens": 2428, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39606818053136394, "lm_q2_score": 0.3380771174808128, "lm_q1q2_score": 0.1339015887999137}}
{"text": "+ This notebook is part of lecture 9 *Independence, basis and dimension* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n+ Created by me, Dr Juan H Klopper\n + Head of Acute Care Surgery\n + Groote Schuur Hospital\n + University Cape Town\n + Email me with your thoughts, comments, suggestions and corrections \nLinear Algebra OCW MIT18.06 IPython notebook [2] study notes by Dr Juan H Klopper is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License .\n\n+ [1] OCW MIT 18.06 \n+ [2] Fernando Pérez, Brian E. Granger, IPython: A System for Interactive Scientific Computing, Computing in Science and Engineering, vol. 9, no. 3, pp. 21-29, May/June 2007, doi:10.1109/MCSE.2007.53. URL: http://ipython.org\n\n\n```python\nfrom IPython.core.display import HTML, Image\ncss_file = 'style.css'\nHTML(open(css_file, 'r').read())\n```\n\n\n\n\n1 , v2 , ..., vn \n\n* If *r* = *n* then the nullspace only contains the zero vector and the column vectors are linearly independent\n\n## Spanning\n\n* If we have a set of linearly independent vector that all their linear combinations (including zero) span a subspace ( in this instance a column space)\n\n* We are particularly interested in a set of (column) vectors (in a matrix) that are linearly independent and span a subspace\n* This leads us to the next topic, **basis**\n\n## Basis\n\n* A set of vectors (in a space *W*) with the properties\n * They are linearly independent\n * They span the space (linear combinations of them fill the space)\n\n* Up until now we looked at columns in a matrix A\n* It is more common in textbooks to look at a space first and ask about basis vectors, spanning vectors, dimension, etc\n\n* So let's look at ℝ3 \n* The obvious set of basis vectors are\n$$ \\hat {i}, \\quad \\hat {j}, \\quad \\hat {k} $$\n\n* What about\n$$ \\begin{bmatrix} 1 \\\\ 1 \\\\ 2 \\end{bmatrix},\\quad \\begin{bmatrix} 2 \\\\ 2 \\\\ 5 \\end{bmatrix} $$\n* So, are they linearly independent and do they span ℝ3 ?|\n\n\n```python\nA = Matrix([[1, 2], [1, 2], [2, 5]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 2\\\\1 & 2\\\\2 & 5\\end{matrix}\\right]$$\n\n\n\n* Here we will have *r* = 2, *n* = 2 and thus a (*n* - *r* = 0) zero nullspace\n\n\n```python\nA.nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\end{bmatrix}$$\n\n\n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0\\\\0 & 1\\\\0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* For now, our intuition is that they will not span ℝ3 \n* This intuition is correct, because all their linear combinations will only fill a plane through the origin\n* The zero combination does result in the zero vector, though, so they do fill a subspace of ℝ3 \n* Some textbooks refer to this as *V* = ℝn , with *W* a subspace of *V*\n\n* If we added a column vector that is a linear combination of these, it will also fall in the plane and thus not be linearly independent (there will be a vector in the nullspace other than the zero vector\n\n\n```python\nA = Matrix([[1, 2, 3], [1, 2, 3], [2, 5, 7]])\nA.nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-1\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & 1\\\\0 & 1 & 1\\\\0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* Indeed, we have a column without a pivot and thus a free variable\n\n* Let's add another, such that we have\n\n\n```python\nA = Matrix([[1, 2, 3], [1, 2, 3], [2, 5, 8]])\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & -1\\\\0 & 1 & 2\\\\0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* Again, a column without a pivot and sure enough, we'll find a vector (other than the zero vector) in the nullspace\n\n\n```python\nA.nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}1\\\\-2\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n### The special case of a square matrix\n\n* If we now end up with a square matrix, we need only look at it's determinant, i.e., is it invertible\n\n\n```python\nA.det() # .det() calculates the determinant\n```\n\n\n\n\n$$0$$\n\n\n\n* Indeed the determinant is zero as expected\n\n## Dimension\n\n* Given a (sub)space, every basis for that (sub)space has the same number of vectors (there are usally more than one basis for every (sub)space)\n* This called the dimension of a (sub)space\n\n## Important point to remember\n\n* The (sub)space which a set of (column) vectors (matrix of coefficients, A) span, is the set of possible **b**-values\n\n## More examples\n\n#### Example problem\n\n* Consider the column space\n\n\n```python\nA = Matrix([[1, 2, 3, 1], [1, 1, 2, 1], [1, 2, 3, 1]])\n```\n\n\n```python\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 2 & 3 & 1\\\\1 & 1 & 2 & 1\\\\1 & 2 & 3 & 1\\end{matrix}\\right]$$\n\n\n\n* There are *n* = 4 unknowns, *m* = 3 unknowns\n* We note that column 1 = column 4\n* We note that with 4 unknowns we are dealing with ℝ4 \n* In essence, there are at most three independent columns, thus the matrix cannot be a basis for ℝ4 \n* It is possible for them to span the column space (don't get confused by column space (ℝ4 ) and matrix here)\n\n\n```python\nA.nullspace()\n```\n\n\n\n\n$$\\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-1\\\\1\\\\0\\end{matrix}\\right], & \\left[\\begin{matrix}-1\\\\0\\\\0\\\\1\\end{matrix}\\right]\\end{bmatrix}$$\n\n\n\n\n```python\nA.rref()\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}1 & 0 & 1 & 1\\\\0 & 1 & 1 & 0\\\\0 & 0 & 0 & 0\\end{matrix}\\right], & \\begin{bmatrix}0, & 1\\end{bmatrix}\\end{pmatrix}$$\n\n\n\n* As we can see here (columns three and four have free variables, i.e. no pivots)\n$$ { x }_{ 1 }+0{ x }_{ 2 }+{ x }_{ 3 }+{ x }_{ 4 }=0\\\\ 0{ x }_{ 1 }+1{ x }_{ 2 }+{ x }_{ 3 }+{ 0 }_{ 4 }=0\\\\ { x }_{ 4 }={ c }_{ 2 }\\\\ { x }_{ 3 }={ c }_{ 1 }\\\\ \\therefore \\quad { x }_{ 2 }=-{ c }_{ 1 }\\\\ \\therefore \\quad { x }_{ 1 }=-{ c }_{ 1 }-{ c }_{ 2 }\\\\ \\begin{bmatrix} { x }_{ 1 } \\\\ { x }_{ 2 } \\\\ { x }_{ 3 } \\\\ { x }_{ 4 } \\end{bmatrix}=\\begin{bmatrix} -{ c }_{ 1 }-{ c }_{ 2 } \\\\ -{ c }_{ 1 } \\\\ { c }_{ 1 } \\\\ { c }_{ 2 } \\end{bmatrix}=\\begin{bmatrix} -{ c }_{ 1 } \\\\ -{ c }_{ 1 } \\\\ { c }_{ 1 } \\\\ 0 \\end{bmatrix}+\\begin{bmatrix} -{ c }_{ 2 } \\\\ 0 \\\\ 0 \\\\ { c }_{ 2 } \\end{bmatrix}={ c }_{ 1 }\\begin{bmatrix} -1 \\\\ -1 \\\\ 1 \\\\ 0 \\end{bmatrix}+{ c }_{ 2 }\\begin{bmatrix} -1 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix} $$\n\n* The rank of the matrix is two (it is the number of pivot columns)\n* This matrix space thus have two basis vectors (column vectors 1 and 2) and we say the dimension of this space is two\n* Remember, a matrix has a rank, which is the dimension of a column space (the column space representing the space 'produced' by the column vectors)\n* We talk about the rank of a matrix, rank(A) and the column space of a matrix, C(A)\n\n* In summary we have two basis above (they span a space)\n * Any two vectors that are not linearly dependent will also span this space, they can't help but to\n * dimC(A)= *r*\n * The nullspace will have *n* - *r* vectors (the dimension of the null space equal the number of free variables)\n\n\n```python\n\n```\n", "meta": {"hexsha": "73b0582178443ddc8de81b29047686b3aaac4ab4", "size": 23713, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/I_10_Independence_Spanning_Basis_Dimension.ipynb", "max_stars_repo_name": "solomonxie/jupyter-notebooks", "max_stars_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-13T05:52:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T09:52:35.000Z", "max_issues_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/I_10_Independence_Spanning_Basis_Dimension.ipynb", "max_issues_repo_name": "solomonxie/jupyter-notebooks", "max_issues_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/I_10_Independence_Spanning_Basis_Dimension.ipynb", "max_forks_repo_name": "solomonxie/jupyter-notebooks", "max_forks_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1005714286, "max_line_length": 788, "alphanum_fraction": 0.4874541391, "converted": true, "num_tokens": 3774, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.27825679968760103, "lm_q1q2_score": 0.13369645927173981}}
{"text": "Tài liệu này mang giấy phép Creative Commons Attribution (CC BY). (c) Nguyễn Ngọc Sáng, Zhukovsky 06/2019.\n\n[@SangVn](https://github.com/SangVn) [@VnCFD](https://vncfdgroup.wordpress.com/)\n\n*Thực hành CFD với Python!*\n\n## Phần 3: Hệ phương trình Euler hai chiều, vncfd_2D\n`Nếu không đào bới thì còn gì là thú vị!`\n\nBạn hãy tưởng tượng việc `nghiên cứu CFD` giống như hành trình `đi tìm kho báu`. Đứng trong một khu rừng nhiệt đới rậm rạp, trên bãi biển của một hòn đảo hoang sơ hay đứng trước đại dương rộng lớn, ta tự hỏi không biết nên làm những gì, đi đến đâu... Chúng ta cần những lời chỉ dẫn, cần `một chiếc bản đồ kho báu`. Những bài báo, những quyển sách về lưu chất, phương pháp tính, về CFD chính là tờ bản đồ kho báu đó. Chúng ta đọc, nghiên cứu và đi theo, chúng ta đã tới được `những nơi được đánh dấu` trên bản đồ. Thế nhưng, trong tay ta `không có một tấc sắt`, không có một `chiếc xẻng` để đào bới... `Chương trình CFD` chính là chiếc xẻng để ta khám phá kho báu, đào hay chôn. Mà `nếu không đào bới thì còn gì là thú vị!`. Chúng ta cần rèn một cái xẻng. Nó có thể được rèn bằng Python, bằng C++, bằng FORTRAN, MATLAB... hay một `vật liệu` nào khác. Khi chúng ta đã biết cách rèn xẻng, biết cách sử dụng một dạng vật liệu thì việc chuyển sang rèn bằng một vật liệu khác không quá phức tạp. \n\nTóm lại là ta cần một **công cụ** để đào sâu nghiên cứu CFD.\n\nKhóa học **Thực hành CFD với Python!** sẽ cho bạn những lời chỉ dẫn, một mảnh của tấm bản đồ và cách rèn xẻng cho hành trình `đi tìm kho báu`.\n \nChúng ta chỉ mới đi được 2 bước: ở **[phần I](https://github.com/SangVn/CFD_Notebook_P1) và [phần II](https://github.com/SangVn/CFD_Notebook_P2)** ta đã tìm hiểu về phương pháp tính, ứng dụng giải các phương trình, hệ phương trình đặc trưng từ đơn giản tới phức tạp, ta đã dừng lại ở hệ phương trình Euler một chiều. Còn đó hệ phương trình Euler hai chiều, ba chiều; hệ phương trình Navier-Stokes; các mô hình rối Spalart-Allmaras, k-omega, k-epsilon, SST, LES, DNS....\n\nThực ra 3D so với 2D thì `chỉ là` thêm 1D, Navier-Stokes hay các mô hình rối so với Euler thì chỉ là thêm một biến, hai biến. Tất nhiên trong cái từ `chỉ là` ấy còn nhiều khác biệt, nhưng khi ta đã có nền tảng để phát triển ta có thể làm được nhiều thứ.\n\nPhần 3 `Thực hành CFD với Python!` sẽ xoay quanh việc xây dựng chương trình giải hệ phương trình Euler 2D. Việc chuyển từ 1D sang 2D là một bước đi quan trọng và thú vị. Phần này tập trung giải thích cấu trúc chương trình, cấu trúc dữ liệu, nhiều phần lý thuyết chỉ dừng lại ở việc giới thiệu tài liệu để bạn đọc tự tham khảo. Chương trình sử dụng **phương pháp thể tích hữu hạn; phương pháp tính dòng Godunov, Roe; sơ đồ hiện, bậc một theo thời gian; tái cấu trúc nghiệm bậc một Godunov, lưới có cấu trúc** và được viết bằng ngôn ngữ `python2.7`. Ta cũng sẽ làm quen với phần mềm `ParaView` để biểu diễn và xử lý kết quả. Các bài toán ví dụ bao gồm: **dòng chảy trên âm qua dốc; dòng chảy bao hình trụ, NACA profile và tàu vũ trụ Crew Dragon**.\n\n\n\nĐể chuẩn bị cho phần 3, các bạn hãy cài đặt và học cách sử dụng **PyCharm** để viết code và **ParaView** để biểu diễn và xử lý dữ liệu CFD.\n\n**Tài liệu tham khảo:**\n- Eleuterio F. Toro `Riemann Solvers and Numerical Methods for Fluid Dynamics`\n- Randall J. Leveque `Finite-Volume Methods for Hyperbolic Problems`\n- H. K. Versteeg, W. Malalasekera `An introduction to Computational Fluid Dynamics. The Finite Volume Method`\n- Katake Masatsuka `I do like CFD. Governing Equations and Exact Solutions`\n- F. Moukalled, L. Mangani, M. Darwish `The Finite Volume Method in Computational Fluid Dynamics. An Advanced Introduction with OpenFOAM and Matlab`\n\n\n# Bài 18. Hệ phương trình Euler hai chiều, phương pháp giải\n\nCác kiến thức cơ bản đã được giới thiệu trong phần II, sau đây ta tóm tắt một số điểm cơ bản.\n\n# 1. Hệ phương trình Euler hai chiều (2D)\n\nĐã được giới thiệu trong [bài 16, phần II](https://nbviewer.jupyter.org/github/SangVn/CFD_Notebook_P2/blob/master/Bai_16.ipynb)\n\nDòng chảy của khí lý tưởng trong hai chiều không gian được mô tả bởi hệ phương trình Euler 2D:\n$$\\frac{\\partial U}{\\partial t} + \\frac{\\partial F}{\\partial x} + \\frac{\\partial G}{\\partial y} = 0\\qquad(1)$$\nvới \n\\begin{align}\nU & = \\begin{pmatrix} \\rho \\\\ \\rho u \\\\ \\rho v \\\\ \\rho e\\end{pmatrix}, &\nF & = \\begin{pmatrix} \\rho u \\\\ \\rho u^2 + p \\\\ \\rho u v \\\\ \\rho uh\\end{pmatrix} &\nG & = \\begin{pmatrix} \\rho v \\\\ \\rho uv \\\\ \\rho v^2 + p \\\\ \\rho vh\\end{pmatrix} &\n\\end{align}\nvà $h = e + \\frac{p}{\\rho}$, $e = \\varepsilon + \\frac{u^2+v^2}{2}$, $\\varepsilon = \\frac{p}{(\\gamma-1)\\rho}$;\n\ntrong đó: $\\rho$ - khối lượng riêng; $u, v$ - vận tốc theo phương x, y; $p$ - áp suất; $e$ - năng lượng một đơn vị khối lượng chất khí; $\\varepsilon$ - nội năng; $h$ - enthalpy.\n\n# 2. Phương pháp thể tích hữu hạn\n\nĐã được giới thiệu trong [bài 11, phần II](https://nbviewer.jupyter.org/github/SangVn/CFD_Notebook_P2/blob/master/Bai_11.ipynb)\n\n\n\nXét `thể tích hữu hạn` ABCD (hình phải) không nằm trên biên, có các `bề mặt` AB, BC, CD, DA; lấy tích phân phương trình (1):\n\n$$\\int_{ABCD} \\left(\\frac{\\partial U}{\\partial t} + \\frac{\\partial F}{\\partial x} + \\frac{\\partial G}{\\partial y} \\right)dxdy = 0$$\n\náp dụng định lý Green ta thu được phương trình dạng tích phân:\n$$\\frac{d}{dt}\\int U dV + \\oint_{ABCD} \\vec F. \\vec n ds = 0 \\qquad (2)$$\nvới $\\vec F = (F, G)$, $\\vec n$ - vector pháp tuyến đơn vị, $\\vec n ds = (dy, -dx)$.\n\nPhương trình (2) mô tả định luật `bảo toàn` khối lượng, động lượng và năng lượng. Nó gồm hai thành phần tương ứng sự biến đổi theo thời gian và dòng đi qua các bề mặt.\n\n### Sơ đồ sai phân \nSơ đồ sai phân của phương trình (2) với xấp xỉ thời gian bậc một có dạng:\n$$\\frac{U^{n+1} - U^n}{\\Delta t} + \\frac{1}{V_{ABCD}} (\\vec F.\\vec S_{AB} + \\vec F.\\vec S_{BC} + \\vec F.\\vec S_{CD} + \\vec F.\\vec S_{DA}) = 0 \\qquad (3)$$\nvới:\n\n$U^n = \\frac{1}{V_{ABCD}}\\int U dV$ - giá trị trung bình của U trong thể tích đang xét tại thời điểm $t$, $V_{ABCD}$ - thể tích hữu hạn (trường hợp 2D - diện tích ABCD);\n\n$\\vec S = \\vec n . S$ - vector pháp tuyến bề mặt S, có độ lớn bằng diện tích bề mặt (2D - độ dài AB, BC, CD, DA).\n\nTa có công thức xác định $U^{n+1}$ tại thời điểm $t+\\Delta t$:\n\n$$U^{n+1} = U^n + \\frac{\\Delta t}{V_{ABCD}}\\sum {\\vec F.\\vec S_n} \\qquad (4)$$\nvới $\\vec S_n = -\\vec n . S = -(nx, ny).S$\n\n### Công thức tính dòng qua bề mặt\nCông thức tính dòng qua một đơn vị diện tích bề mặt:\n\\begin{align}\nFlux = \\vec F.(\\vec n) = (F, G).(nx,ny) & = \\begin{pmatrix} \\rho(un_x+vn_y) \\\\ \\rho u(un_x+vn_y) + pn_x \\\\ \\rho v(un_x+vn_y) + pn_y \\\\ \\rho h(un_x+vn_y)\\end{pmatrix}, &\n\\end{align}\n\nTrong đó $un_x+vn_y = V_n$ - vận tốc của dòng chảy theo phương vuông góc với bề mặt. Ta có:\n\n\\begin{align}\nFlux & = \\begin{pmatrix} \\rho V_n \\\\ \\rho uV_n + pn_x \\\\ \\rho vV_n + pn_y \\\\ \\rho hV_n\\end{pmatrix}, &\n\\end{align}\n\n\n## Các điểm chú ý\n\nSo với phương pháp giải hệ phương trình Euler 1D ở phần 2, khi giải hệ trong không gian hai chiều (2D) chúng ta sẽ cần phải quan tâm kỹ tới các vấn đề: đặc tính hình học; lưới; cấu trúc dữ liệu; điều kiện biên; biểu diễn, xử lý kết quả. \n\nTa sẽ bắt đầu thực hành với việc tạo lưới cho bài toán dòng chảy trên âm ở bài sau.\n\n\n# [Bài 19. Dựng lưới có cấu trúc ](Bai_19.ipynb)\n\n\n\n\n\n", "meta": {"hexsha": "7fa490014bf67c1fce0477c5b5ca9414ce6ae73b", "size": 9161, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Bai_18.ipynb", "max_stars_repo_name": "SangVn/CFD_Notebook_P3", "max_stars_repo_head_hexsha": "1c8db538391ddd6d762bbfd2f59a4059ece5f84e", "max_stars_repo_licenses": ["CC-BY-3.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-07-10T02:21:42.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-27T16:43:50.000Z", "max_issues_repo_path": "Bai_18.ipynb", "max_issues_repo_name": "TIENBUIHUU/CFD_Notebook_P3", "max_issues_repo_head_hexsha": "1c8db538391ddd6d762bbfd2f59a4059ece5f84e", "max_issues_repo_licenses": ["CC-BY-3.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Bai_18.ipynb", "max_forks_repo_name": "TIENBUIHUU/CFD_Notebook_P3", "max_forks_repo_head_hexsha": "1c8db538391ddd6d762bbfd2f59a4059ece5f84e", "max_forks_repo_licenses": ["CC-BY-3.0"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2019-09-04T18:49:16.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-27T16:43:51.000Z", "avg_line_length": 56.900621118, "max_line_length": 999, "alphanum_fraction": 0.6045191573, "converted": true, "num_tokens": 3254, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4726834617637482, "lm_q2_score": 0.28140560742914383, "lm_q1q2_score": 0.13301577667933806}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: Pyro\n-----\n\n\n\n```python\nfrom jax import random\nimport jax\nimport jax.numpy as np\nimport numpyro as pyro\nimport numpyro.distributions as dist\n```\n\n\n```python\ncount_data = jax.numpy.array(count_data)\n```\n\n\n```python\ndef model(data):\n alpha = (1. / data.mean())\n lambda1 = pyro.sample(\"lambda_1\", dist.Exponential(rate=alpha))\n lambda2 = pyro.sample(\"lambda_2\", dist.Exponential(rate=alpha))\n\n tau = pyro.sample(\"tau\", dist.Uniform(0, 1))\n\n lambda12 = np.where(np.arange(len(data)) < tau * len(data), lambda1, lambda2)\n pyro.sample('obs', dist.Poisson(lambda12), obs=data)\n```\n\n\n```python\nnuts_kernel = pyro.infer.NUTS(model)\nposterior = pyro.infer.MCMC(nuts_kernel, num_samples=10000, num_warmup=5000) # 100x faster than pyro\nrng_key = random.PRNGKey(0)\nposterior.run(rng_key, count_data)\n```\n\n sample: 100%|██████████| 15000/15000 [00:26<00:00, 569.63it/s, 1023 steps of size 2.41e-03. acc. prob=0.75]\n\n\n\n```python\nlambda_1_samples = posterior.get_samples()['lambda_1']\nlambda_2_samples = posterior.get_samples()['lambda_2']\ntau_samples = posterior.get_samples()['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\ntau_samples = np.array((tau_samples * count_data.size + 1), dtype=np.int32)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day = jax.ops.index_update(expected_texts_per_day, day, (lambda_1_samples[ix].sum() + lambda_2_samples[~ix].sum()) / N)\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n#type your code here.\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n#type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0c55bdd60019116db224c53c869de93885f0ef71", "size": 289981, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_numpyro.ipynb", "max_stars_repo_name": "davinnovation/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "7280687a4cadb2d273a41f037aeb8d4619cc160a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_numpyro.ipynb", "max_issues_repo_name": "davinnovation/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "7280687a4cadb2d273a41f037aeb8d4619cc160a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_numpyro.ipynb", "max_forks_repo_name": "davinnovation/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "7280687a4cadb2d273a41f037aeb8d4619cc160a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 280.1748792271, "max_line_length": 86088, "alphanum_fraction": 0.9015763102, "converted": true, "num_tokens": 10732, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295350395727, "lm_q2_score": 0.2974699426047947, "lm_q1q2_score": 0.13253164521696256}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pylab as plt\nimport seaborn as sns\nsns.set_context('notebook')\n\nRANDOM_SEED = 20090425\n```\n\n---\n\n# Comparing Two Groups with a Continuous or Binary Outcome\n\nStatistical inference is a process of learning from incomplete or imperfect (error-contaminated) data. Can account for this \"imperfection\" using either a sampling model or a measurement error model.\n\n### Statistical hypothesis testing\n\nThe *de facto* standard for statistical inference is statistical hypothesis testing. The goal of hypothesis testing is to evaluate a **null hypothesis**. There are two possible outcomes:\n\n- reject the null hypothesis\n- fail to reject the null hypothesis\n\nRejection occurs when a chosen test statistic is higher than some pre-specified threshold valuel; non-rejection occurs otherwise.\n\n\n\nNotice that neither outcome says anything about the quantity of interest, the **research hypothesis**. \n\nSetting up a statistical test involves several subjective choices by the user that are rarely justified based on the problem or decision at hand:\n\n- statistical test to use\n- null hypothesis to test\n- significance level\n\nChoices are often based on arbitrary criteria, including \"statistical tradition\" (Johnson 1999). The resulting evidence is indirect, incomplete, and typically overstates the evidence against the null hypothesis (Goodman 1999).\n\nMost importantly to applied users, the results of statistical hypothesis tests are very easy to misinterpret. \n\n### Estimation \n\nInstead of testing, a more informative and effective approach for inference is based on **estimation** (be it frequentist or Bayesian). That is, rather than testing whether two groups are different, we instead pursue an estimate of *how different* they are, which is fundamentally more informative. \n\nAdditionally, we include an estimate of **uncertainty** associated with that difference which includes uncertainty due to our lack of knowledge of the model parameters (*epistemic uncertainty*) and uncertainty due to the inherent stochasticity of the system (*aleatory uncertainty*).\n\n# An Introduction to Bayesian Statistical Analysis\n\nThough many of you will have taken a statistics course or two during your undergraduate (or graduate education, most of those who have will likely not have had a course in *Bayesian* statistics. Most introductory courses, particularly for non-statisticians, still do not cover Bayesian methods at all. Even today, Bayesian courses (similarly to statistical computing courses!) are typically tacked onto the curriculum, rather than being integrated into the program.\n\nIn fact, Bayesian statistics is not just a particular method, or even a class of methods; it is an entirely **different paradigm** for doing statistical analysis.\n\n> Practical methods for making inferences from data using probability models for quantities we observe and about which we wish to learn.\n*-- Gelman et al. 2013*\n\nA Bayesian model is described by parameters, uncertainty in those parameters is described using probability distributions.\n\nAll conclusions from Bayesian statistical procedures are stated in terms of **probability statements**\n\n\n\nThis confers several benefits to the analyst, including:\n\n- ease of interpretation, summarization of uncertainty\n- can incorporate uncertainty in parent parameters\n- easy to calculate summary statistics\n\n### Bayesian vs Frequentist Statistics: *What's the difference?*\n\nAny statistical inferece paradigm, Bayesian or otherwise, involves at least the following: \n\n1. Some **unknown quantities** about which we are interested in learning or testing. We call these *parameters*.\n2. Some **data** which have been observed, and hopefully contain information about.\n3. One or more **models** that relate the data to the parameters, and is the instrument that is used to learn.\n\n\n\n### The Frequentist World View\n\n\n\n- The **data** that have been observed are considered **random**, because they are realizations of random processes, and hence will vary each time one goes to observe the system.\n- Model **parameters** are considered **fixed**. A parameter's true value is uknown and fixed, and so we *condition* on them.\n\nIn mathematical notation, this implies a (very) general model of the following form:\n\n\n\\\\[f(y | \\theta)\\\\]\n
\n\nHere, the model \\\\(f\\\\) accepts data values \\\\(y\\\\) as an argument, conditional on particular values of \\\\(\\theta\\\\).\n\nFrequentist inference typically involves deriving **estimators** for the unknown parameters. Estimators are formulae that return estimates for particular estimands, as a function of data. They are selected based on some chosen optimality criterion, such as *unbiasedness*, *variance minimization*, or *efficiency*.\n\n> For example, lets say that we have collected some data on the prevalence of autism spectrum disorder (ASD) in some defined population. Our sample includes \\\\(n\\\\) sampled children, \\\\(y\\\\) of them having been diagnosed with autism. A frequentist estimator of the prevalence \\\\(p\\\\) is:\n\n> \n> $$\\hat{p} = \\frac{y}{n}$$\n>
\n\n> Why this particular function? Because it can be shown to be unbiased and minimum-variance.\n\nIt is important to note that, in a frequentist world, new estimators need to be derived for every estimand that is introduced.\n\n### The Bayesian World View\n\n\n\n- Data are considered **fixed**. They used to be random, but once they were written into your lab notebook/spreadsheet/IPython notebook they do not change.\n- Model parameters themselves may not be random, but Bayesians use probability distribtutions to describe their uncertainty in parameter values, and are therefore treated as **random**. In some cases, it is useful to consider parameters as having been sampled from probability distributions.\n\nThis implies the following form:\n\n\n\\\\[p(\\theta | y)\\\\]\n
\n\nThis formulation used to be referred to as ***inverse probability***, because it infers from observations to parameters, or from effects to causes.\n\nBayesians do not seek new estimators for every estimation problem they encounter. There is only one estimator for Bayesian inference: **Bayes' Formula**.\n\n## Bayes' Formula\n\nNow that we have some probability under our belt, we turn to Bayes' formula. While frequentist statistics uses different estimators for different problems, Bayes formula is the **only estimator** that Bayesians need to obtain estimates of unknown quantities that we care about. \n\n\n\nThe equation expresses how our belief about the value of \\\\(\\theta\\\\), as expressed by the **prior distribution** \\\\(P(\\theta)\\\\) is reallocated following the observation of the data \\\\(y\\\\).\n\nThe innocuous denominator \\\\(P(y)\\\\) usuallt cannot be computed directly, and is actually the expression in the numerator, integrated over all \\\\(\\theta\\\\):\n\n \n\\\\[Pr(\\theta|y) = \\frac{Pr(y|\\theta)Pr(\\theta)}{\\int Pr(y|\\theta)Pr(\\theta) d\\theta}\\\\]\n
\n\nThe intractability of this integral is one of the factors that has contributed to the under-utilization of Bayesian methods by statisticians.\n\n### Priors\n\nOnce considered a controversial aspect of Bayesian analysis, the prior distribution characterizes what is known about an unknown quantity before observing the data from the present study. Thus, it represents the information state of that parameter. It can be used to reflect the information obtained in previous studies, to constrain the parameter to plausible values, or to represent the population of possible parameter values, of which the current study's parameter value can be considered a sample.\n\n### Likelihood functions\n\nThe likelihood represents the information in the observed data, and is used to update prior distributions to posterior distributions. This updating of belief is justified becuase of the **likelihood principle**, which states:\n\n> Following observation of \\\\(y\\\\), the likelihood \\\\(L(\\theta|y)\\\\) contains all experimental information from \\\\(y\\\\) about the unknown \\\\(\\theta\\\\).\n\nBayesian analysis satisfies the likelihood principle because the posterior distribution's dependence on the data is **only through the likelihood**. In comparison, most frequentist inference procedures violate the likelihood principle, because inference will depend on the design of the trial or experiment.\n\nRemember from the density estimation section that the likelihood is closely related to the probability density (or mass) function. The difference is that the likelihood varies the parameter while holding the observations constant, rather than *vice versa*.\n\n## Bayesian Inference, in 3 Easy Steps\n\n\n\nGelman et al. (2013) describe the process of conducting Bayesian statistical analysis in 3 steps.\n\n### Step 1: Specify a probability model\n\nAs was noted above, Bayesian statistics involves using probability models to solve problems. So, the first task is to *completely specify* the model in terms of probability distributions. This includes everything: unknown parameters, data, covariates, missing data, predictions. All must be assigned some probability density.\n\nThis step involves making choices.\n\n- what is the form of the sampling distribution of the data?\n- what form best describes our uncertainty in the unknown parameters?\n\n### Discrete Random Variables\n\n$$X = \\{0,1\\}$$\n\n$$Y = \\{\\ldots,-2,-1,0,1,2,\\ldots\\}$$\n\n**Probability Mass Function**: \n\nFor discrete $X$,\n\n$$Pr(X=x) = f(x|\\theta)$$\n\n\n\n***e.g. Poisson distribution***\n\nThe Poisson distribution models unbounded counts:\n\n \n$$Pr(X=x)=\\frac{e^{-\\lambda}\\lambda^x}{x!}$$\n
\n\n* $X=\\{0,1,2,\\ldots\\}$\n* $\\lambda > 0$\n\n$$E(X) = \\text{Var}(X) = \\lambda$$\n\n\n```python\nfrom pymc3 import Poisson\n\nx = Poisson.dist(mu=1)\nsamples = x.random(size=10000)\n```\n\n\n```python\nsamples.mean()\n```\n\n\n\n\n 1.0073000000000001\n\n\n\n\n```python\nplt.hist(samples, bins=len(set(samples)));\n```\n\n### Continuous Random Variables\n\n$$X \\in [0,1]$$\n\n$$Y \\in (-\\infty, \\infty)$$\n\n**Probability Density Function**: \n\nFor continuous $X$,\n\n$$Pr(x \\le X \\le x + dx) = f(x|\\theta)dx \\, \\text{ as } \\, dx \\rightarrow 0$$\n\n\n\n***e.g. normal distribution***\n\n \n$$f(x) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}}\\exp\\left[-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right]$$\n
\n\n* $X \\in \\mathbf{R}$\n* $\\mu \\in \\mathbf{R}$\n* $\\sigma>0$\n\n$$\\begin{align}E(X) &= \\mu \\cr\n\\text{Var}(X) &= \\sigma^2 \\end{align}$$\n\n\n```python\nfrom pymc3 import Normal\n\ny = Normal.dist(mu=-2, sd=4)\nsamples = y.random(size=10000)\n```\n\n\n```python\nsamples.mean()\n```\n\n\n\n\n -1.9495826503791522\n\n\n\n\n```python\nsamples.std()\n```\n\n\n\n\n 3.9997450711227618\n\n\n\n\n```python\nplt.hist(samples);\n```\n\n### Step 2: Calculate a posterior distribution\n\nThe mathematical form \\\\(p(\\theta | y)\\\\) that we associated with the Bayesian approach is referred to as a **posterior distribution**.\n\n> posterior /pos·ter·i·or/ (pos-tēr´e-er) later in time; subsequent.\n\nWhy posterior? Because it tells us what we know about the unknown \\\\(\\theta\\\\) *after* having observed \\\\(y\\\\).\n\nThis posterior distribution is formulated as a function of the probability model that was specified in Step 1. Usually, we can write it down but we cannot calculate it analytically. In fact, the difficulty inherent in calculating the posterior distribution for most models of interest is perhaps the major contributing factor for the lack of widespread adoption of Bayesian methods for data analysis. Various strategies for doing so comprise this tutorial.\n\n**But**, once the posterior distribution is calculated, you get a lot for free:\n\n- point estimates\n- credible intervals\n- quantiles\n- predictions\n\n### Step 3: Check your model\n\nThough frequently ignored in practice, it is critical that the model and its outputs be assessed before using the outputs for inference. Models are specified based on assumptions that are largely unverifiable, so the least we can do is examine the output in detail, relative to the specified model and the data that were used to fit the model.\n\nSpecifically, we must ask:\n\n- does the model fit data?\n- are the conclusions reasonable?\n- are the outputs sensitive to changes in model structure?\n\n\n\n## Estimation for one group\n\nBefore we compare two groups using Bayesian analysis, let's start with an even simpler scenario: statistical inference for one group.\n\nFor this we will use Gelman et al.'s (2007) radon dataset. In this dataset the amount of the radioactive gas radon has been measured among different households in all counties of several states. Radon gas is known to be the highest cause of lung cancer in non-smokers. It is believed to be more strongly present in households containing a basement and to differ in amount present among types of soil.\n\n> the US EPA has set an action level of 4 pCi/L. At or above this level of radon, the EPA recommends you take corrective measures to reduce your exposure to radon gas.\n\n\n\nLet's import the dataset:\n\n\n```python\nradon = pd.read_csv('../data/radon.csv', index_col=0)\nradon.head()\n```\n\n\n\n\n\n
\n \n \n idnum \n state \n state2 \n stfips \n zip \n region \n typebldg \n floor \n room \n basement \n ... \n pcterr \n adjwt \n dupflag \n zipflag \n cntyfips \n county \n fips \n Uppm \n county_code \n log_radon \n \n \n \n \n 0 \n 5081.0 \n MN \n MN \n 27.0 \n 55735 \n 5.0 \n 1.0 \n 1.0 \n 3.0 \n N \n ... \n 9.7 \n 1146.499190 \n 1.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 0.832909 \n \n \n 1 \n 5082.0 \n MN \n MN \n 27.0 \n 55748 \n 5.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 14.5 \n 471.366223 \n 0.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 0.832909 \n \n \n 2 \n 5083.0 \n MN \n MN \n 27.0 \n 55748 \n 5.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 9.6 \n 433.316718 \n 0.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 1.098612 \n \n \n 3 \n 5084.0 \n MN \n MN \n 27.0 \n 56469 \n 5.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 24.3 \n 461.623670 \n 0.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 0.095310 \n \n \n 4 \n 5085.0 \n MN \n MN \n 27.0 \n 55011 \n 3.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 13.8 \n 433.316718 \n 0.0 \n 0.0 \n 3.0 \n ANOKA \n 27003.0 \n 0.428565 \n 1 \n 1.163151 \n \n \n
\n
5 rows × 29 columns
\n
\n
\n \n \n Jan \n Feb \n Mar \n Apr \n May \n Jun \n Jul \n Aug \n Sep \n Oct \n Nov \n Dec \n \n \n Year \n \n \n \n \n 1871 \n 2.76 \n 4.58 \n 5.01 \n 4.13 \n 3.30 \n 2.98 \n 1.58 \n 2.36 \n 0.95 \n 1.31 \n 2.13 \n 1.65 \n \n \n 1872 \n 2.32 \n 2.11 \n 3.14 \n 5.91 \n 3.09 \n 5.17 \n 6.10 \n 1.65 \n 4.50 \n 1.58 \n 2.25 \n 2.38 \n \n \n 1873 \n 2.96 \n 7.14 \n 4.11 \n 3.59 \n 6.31 \n 4.20 \n 4.63 \n 2.36 \n 1.81 \n 4.28 \n 4.36 \n 5.94 \n \n \n 1874 \n 5.22 \n 9.23 \n 5.36 \n 11.84 \n 1.49 \n 2.87 \n 2.65 \n 3.52 \n 3.12 \n 2.63 \n 6.12 \n 4.19 \n \n \n 1875 \n 6.15 \n 3.06 \n 8.14 \n 4.22 \n 1.73 \n 5.63 \n 8.12 \n 1.60 \n 3.79 \n 1.25 \n 5.46 \n 4.30 \n \n \n
\n
\n
\n \n \n birth \n exit \n hospstay \n lowph \n pltct \n race \n bwt \n gest \n inout \n twn \n ... \n vent \n pneumo \n pda \n cld \n pvh \n ivh \n ipe \n year \n sex \n dead \n \n \n \n \n 5 \n 81.593002 \n 81.598999 \n 2.0 \n 6.969997 \n 54.0 \n black \n 925.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 1.0 \n 1.0 \n 0.0 \n 0.0 \n definite \n definite \n NaN \n 81.594055 \n female \n 1 \n \n \n 6 \n 81.601997 \n 81.771004 \n 62.0 \n 7.189999 \n NaN \n white \n 940.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 1.0 \n 0.0 \n 0.0 \n 0.0 \n absent \n absent \n absent \n 81.602295 \n female \n 0 \n \n \n 13 \n 81.683998 \n 81.853996 \n 62.0 \n 7.179996 \n 182.0 \n black \n 1110.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 0.0 \n 1.0 \n 0.0 \n 1.0 \n absent \n absent \n absent \n 81.684448 \n male \n 0 \n \n \n 14 \n 81.689003 \n 81.877998 \n 69.0 \n 7.419998 \n 361.0 \n white \n 1180.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n absent \n absent \n absent \n 81.689880 \n male \n 0 \n \n \n 16 \n 81.696999 \n 81.952004 \n 93.0 \n 7.239998 \n 255.0 \n black \n 770.0 \n 26.0 \n born at Duke \n 0.0 \n ... \n 1.0 \n 0.0 \n 0.0 \n 1.0 \n absent \n absent \n absent \n 81.698120 \n male \n 0 \n \n \n
\n
5 rows × 26 columns
\n
\n
\n \n \n pneumo \n 0.0 \n 1.0 \n \n \n ivh \n \n \n \n \n absent \n 359 \n 73 \n \n \n definite \n 45 \n 30 \n \n \n possible \n 6 \n 4 \n \n \n
\n
\n\n\n\n\n```python\nfor k in map(sp,range(5)):\n print(k)\n```\n\n 41\n 43\n 47\n 53\n 61\n\n\n\n```python\nlist(map(sp,range(5)))\n```\n\n\n\n\n [41, 43, 47, 53, 61]\n\n\n\n\n```python\nlist(filter(lambda x: x%2 == 1, range(10)))\n```\n\n\n\n\n [1, 3, 5, 7, 9]\n\n\n\nEs poco frecuente usar explícitamente map y filter, ya que su efecto se consigue de forma más cómoda con list comprehensions:\n\n\n```python\n[k**2 for k in range(10) if k >5 ]\n```\n\n\n\n\n [36, 49, 64, 81]\n\n\n\n\n```python\ndef divis(n):\n return [k for k in range(2,n) if n%k==0]\n```\n\n\n```python\ndivis(12)\n```\n\n\n\n\n [2, 3, 4, 6]\n\n\n\n\n```python\ndivis(1001)\n```\n\n\n\n\n [7, 11, 13, 77, 91, 143]\n\n\n\n\n```python\ndef perfect(n):\n return sum(divis(n)) + 1 == n\n```\n\n\n```python\nperfect(4)\n```\n\n\n\n\n False\n\n\n\n\n```python\nperfect(6)\n```\n\n\n\n\n True\n\n\n\n\n```python\ndef prime(n):\n return divis(n)==[]\n```\n\n\n```python\n[k for k in range(2,21) if prime(k)]\n```\n\n\n\n\n [2, 3, 5, 7, 11, 13, 17, 19]\n\n\n\n\n```python\nfrom functools import reduce\nimport operator\n\ndef product(l):\n return reduce(operator.mul,l,1)\n```\n\n\n```python\nproduct(range(1,10+1))\n```\n\n\n\n\n 3628800\n\n\n\nFunción que construye funciones:\n\n\n```python\ndef mkfun(y):\n return lambda x: x+y\n```\n\n\n```python\nf = mkfun(1)\ng = mkfun(5)\n\nprint(f(10))\nprint(g(10))\n```\n\n 11\n 15\n\n\n\n```python\nfs = list(map(mkfun,range(1,6)))\n\nprint(fs[0](10))\nprint(fs[4](10))\n```\n\n 11\n 15\n\n\n## Arrays\n\nGran parte del éxito de Python se debe a [numpy](http://www.numpy.org/).\n\n\n```python\nimport numpy as np\n```\n\nConstrucción a partir de listas (u otros contenedores):\n\n\n```python\nm = np.array([[5,3, 2,10],\n [2,0, 7, 0],\n [1,1,-3, 6]])\n```\n\n\n```python\nm[1,2]\n```\n\n\n\n\n 7\n\n\n\nInspección de su tipo y estructura:\n\n\n```python\ntype(m)\n```\n\n\n\n\n numpy.ndarray\n\n\n\n\n```python\nm.dtype\n```\n\n\n\n\n dtype('int64')\n\n\n\n\n```python\nm.shape\n```\n\n\n\n\n (3, 4)\n\n\n\n\n```python\nm.ndim\n```\n\n\n\n\n 2\n\n\n\n\n```python\nlen(m)\n```\n\n\n\n\n 3\n\n\n\n\n```python\nm.size\n```\n\n\n\n\n 12\n\n\n\nLas operaciones elemento a elemento son automáticas:\n\n\n```python\n5*m + 2\n```\n\n\n\n\n array([[ 27, 17, 12, 52],\n [ 12, 2, 37, 2],\n [ 7, 7, -13, 32]])\n\n\n\nConstructores especiales:\n\n\n```python\nnp.zeros([2,3])\n```\n\n\n\n\n array([[0., 0., 0.],\n [0., 0., 0.]])\n\n\n\n\n```python\nnp.ones([4])\n```\n\n\n\n\n array([1., 1., 1., 1.])\n\n\n\n\n```python\nnp.linspace(0,5,11)\n```\n\n\n\n\n array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ])\n\n\n\n\n```python\nnp.arange(10)\n```\n\n\n\n\n array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n\n\n\n```python\nnp.arange(1,10,0.5)\n```\n\n\n\n\n array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. ,\n 7.5, 8. , 8.5, 9. , 9.5])\n\n\n\n\n```python\nnp.eye(7)\n```\n\n\n\n\n array([[1., 0., 0., 0., 0., 0., 0.],\n [0., 1., 0., 0., 0., 0., 0.],\n [0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0.],\n [0., 0., 0., 0., 1., 0., 0.],\n [0., 0., 0., 0., 0., 1., 0.],\n [0., 0., 0., 0., 0., 0., 1.]])\n\n\n\nIteración, a lo largo de la primera dimensión:\n\n\n```python\nfor e in np.arange(4):\n print(e)\n```\n\n 0\n 1\n 2\n 3\n\n\n\n```python\nfor e in m:\n print(e)\n```\n\n [ 5 3 2 10]\n [2 0 7 0]\n [ 1 1 -3 6]\n\n\n\n```python\nsum(m)\n```\n\n\n\n\n array([ 8, 4, 6, 16])\n\n\n\n\n```python\nnp.sum(m,axis=1)\n```\n\n\n\n\n array([20, 9, 5])\n\n\n\nOperaciones matriciales:\n\n\n```python\nm.T\n```\n\n\n\n\n array([[ 5, 2, 1],\n [ 3, 0, 1],\n [ 2, 7, -3],\n [10, 0, 6]])\n\n\n\n\n```python\nv = np.array([3,2,-5,8])\n```\n\nEl producto de matrices, el producto escalar de vectores, y su generalización para arrays multidimensionales se expresa con el símbolo `@` (que representa a la función `dot`).\n\n\n```python\nm @ v\n```\n\n\n\n\n array([ 91, -29, 68])\n\n\n\n\n```python\nnp.diag([10,0,1]) @ m\n```\n\n\n\n\n array([[ 50, 30, 20, 100],\n [ 0, 0, 0, 0],\n [ 1, 1, -3, 6]])\n\n\n\nLas funciones matemáticas están optimizadas para operar con arrays elemento a elemento:\n\n\n```python\nx = np.linspace(0,2*np.pi,30)\n\nx\n```\n\n\n\n\n array([0. , 0.21666156, 0.43332312, 0.64998469, 0.86664625,\n 1.08330781, 1.29996937, 1.51663094, 1.7332925 , 1.94995406,\n 2.16661562, 2.38327719, 2.59993875, 2.81660031, 3.03326187,\n 3.24992343, 3.466585 , 3.68324656, 3.89990812, 4.11656968,\n 4.33323125, 4.54989281, 4.76655437, 4.98321593, 5.1998775 ,\n 5.41653906, 5.63320062, 5.84986218, 6.06652374, 6.28318531])\n\n\n\n\n```python\ny = np.sin(x) + np.cos(2*x)\ny\n```\n\n\n\n\n array([ 1. , 1.12254586, 1.06727539, 0.87270255, 0.60038006,\n 0.32232498, 0.10669282, 0.00439546, 0.03917335, 0.20298123,\n 0.45755084, 0.74183837, 0.9839623 , 1.1153946 , 1.08473957,\n 0.86850154, 0.47679154, -0.04714542, -0.63356055, -1.19782715,\n -1.65497221, -1.93447969, -1.99267137, -1.82040717, -1.44469911,\n -0.92394405, -0.33764588, 0.22749718, 0.69260498, 1. ])\n\n\n\nReconfiguración de los elementos:\n\n\n```python\nnp.arange(12)\n```\n\n\n\n\n array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])\n\n\n\n\n```python\nnp.arange(12).reshape(3,2,2)\n```\n\n\n\n\n array([[[ 0, 1],\n [ 2, 3]],\n \n [[ 4, 5],\n [ 6, 7]],\n \n [[ 8, 9],\n [10, 11]]])\n\n\n\n### Matrices por bloques\n\n\n```python\nnp.append(m,[[100,200,300,400],\n [0, 10, 0, 1] ],axis=0)\n```\n\n\n\n\n array([[ 5, 3, 2, 10],\n [ 2, 0, 7, 0],\n [ 1, 1, -3, 6],\n [100, 200, 300, 400],\n [ 0, 10, 0, 1]])\n\n\n\n\n```python\nnp.hstack([np.zeros([3,3]),np.ones([3,2])])\n```\n\n\n\n\n array([[0., 0., 0., 1., 1.],\n [0., 0., 0., 1., 1.],\n [0., 0., 0., 1., 1.]])\n\n\n\n\n```python\nnp.vstack([np.eye(3),5*np.ones([2,3])])\n```\n\n\n\n\n array([[1., 0., 0.],\n [0., 1., 0.],\n [0., 0., 1.],\n [5., 5., 5.],\n [5., 5., 5.]])\n\n\n\nnumpy proporciona un tipo especial `matrix` para los arrays de 2 dimensiones pero [se recomienda no usarlo](https://stackoverflow.com/questions/4151128/what-are-the-differences-between-numpy-arrays-and-matrices-which-one-should-i-u) o usarlo con cuidado.\n\n### Automatic broadcasting\n\nLas operaciones elemento a elemento argumentos con las mismas dimensiones. Pero si alguna dimensión es igual a uno, se sobreentiende que los elementos se replican en esa dimensión para coincidir con el otro array.\n\n\n```python\nm = np.array([[1, 2, 3, 4]\n ,[5, 6, 7, 8]\n ,[9,10,11,12]])\n```\n\n\n```python\nm + [[10],\n [20],\n [30]]\n```\n\n\n\n\n array([[11, 12, 13, 14],\n [25, 26, 27, 28],\n [39, 40, 41, 42]])\n\n\n\n\n```python\nm + [100,200,300,400]\n```\n\n\n\n\n array([[101, 202, 303, 404],\n [105, 206, 307, 408],\n [109, 210, 311, 412]])\n\n\n\n\n```python\nnp.array([[1,2,3,4]]) + np.array([[100],\n [200],\n [300]])\n```\n\n\n\n\n array([[101, 102, 103, 104],\n [201, 202, 203, 204],\n [301, 302, 303, 304]])\n\n\n\n### Slices\n\nExtracción de elementos y \"submatrices\" o \"subarrays\", seleccionando intervalos de filas, columnas, etc.:\n\n\n```python\nm = np.arange(42).reshape(6,7)\nm\n```\n\n\n\n\n array([[ 0, 1, 2, 3, 4, 5, 6],\n [ 7, 8, 9, 10, 11, 12, 13],\n [14, 15, 16, 17, 18, 19, 20],\n [21, 22, 23, 24, 25, 26, 27],\n [28, 29, 30, 31, 32, 33, 34],\n [35, 36, 37, 38, 39, 40, 41]])\n\n\n\n\n```python\nm[1,2]\n```\n\n\n\n\n 9\n\n\n\n\n```python\nm[2:5,1:4]\n```\n\n\n\n\n array([[15, 16, 17],\n [22, 23, 24],\n [29, 30, 31]])\n\n\n\n\n```python\nm[:3, 4:]\n```\n\n\n\n\n array([[ 4, 5, 6],\n [11, 12, 13],\n [18, 19, 20]])\n\n\n\n\n```python\nm[[1,0,0,2,1],:]\n```\n\n\n\n\n array([[ 7, 8, 9, 10, 11, 12, 13],\n [ 0, 1, 2, 3, 4, 5, 6],\n [ 0, 1, 2, 3, 4, 5, 6],\n [14, 15, 16, 17, 18, 19, 20],\n [ 7, 8, 9, 10, 11, 12, 13]])\n\n\n\nLos índices negativos indican que se empieza a contar desde el final.\n\n\n```python\n# las dos últimas columnas y todas las filas menos las tres últimas.\nm[:-3,-2:]\n```\n\n\n\n\n array([[ 5, 6],\n [12, 13],\n [19, 20]])\n\n\n\n\n```python\n# la penúltima columna\nm[:,-2]\n```\n\n\n\n\n array([ 5, 12, 19, 26, 33, 40])\n\n\n\n\n```python\n# la penúltima columna pero como array 2D (matriz), para que se vea como un vector columna\nm[:,[-2]]\n```\n\n\n\n\n array([[ 5],\n [12],\n [19],\n [26],\n [33],\n [40]])\n\n\n\n### Masks\n\nExtracción de elementos que cumplen una condición:\n\n\n```python\nn = np.arange(10)\n\nn\n```\n\n\n\n\n array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n\n\n\n```python\nn < 5\n```\n\n\n\n\n array([ True, True, True, True, True, False, False, False, False,\n False])\n\n\n\n\n```python\nn[n<5]\n```\n\n\n\n\n array([0, 1, 2, 3, 4])\n\n\n\n\n```python\nk = np.arange(1,101)\n\n(k ** 2)[(k>10) & (k**3 < 2000)]\n```\n\n\n\n\n array([121, 144])\n\n\n\n### I/O\n\nLa función `np.loadtxt` permite cargar los datos de los arrays a partir de ficheros de texto. También es posible guardar y recuperar arrays en formato binario.\n\n## Gráficas\n\nUno de los paquetes gráficos más conocidos es `matplotlib`, que puede utilizarse con un interfaz muy parecido al de Matlab/Octave.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# para insertar los gráficos en el notebook\n%matplotlib inline\n\n# para generar ventanas independientes\n# %matplotlib qt\n# %matplotib tk\n```\n\n\n```python\nx=np.linspace(0,2*np.pi,200)\n```\n\n\n```python\nplt.plot(np.sin(x))\n```\n\n\n```python\nplt.plot(np.cos(x),np.sin(x)); plt.axis('equal');\n```\n\n\n```python\nplt.plot(x,np.sin(x), x,np.cos(x));\n```\n\n\n```python\nplt.plot(x,np.sin(x),color='red')\nplt.plot(x,np.sin(2*x),color='black')\nplt.plot([1,2.5],[-0.5,0],'.',markersize=15);\nplt.legend(['hola','fun','puntos']);\nplt.xlabel('x'); plt.ylabel('y'); plt.title('bonito plot'); plt.axis('tight');\n```\n\nEl gráfico se puede exportar en el formato deseado:\n\n\n```python\n# plt.savefig('result.pdf') # o .svg, .png, .jpg, etc.\n```\n\n\n```python\nplt.plot(x,np.exp(x)); plt.axis([0,3,-1,5]);\n```\n\n\n```python\nfor k in [1,2,3]:\n plt.plot(x,np.sin(k*x))\nplt.grid()\n```\n\n\n```python\ndef espiral(n):\n t = np.linspace(0,n*2*np.pi,1000)\n r = 3 * t\n x = r * np.cos(t)\n y = r * np.sin(t)\n plt.plot(x,y)\n plt.axis('equal')\n plt.axis('off')\n\nespiral(4)\n```\n\n\n```python\nimport numpy.random as rnd\n\ndef randwalk(n,s):\n p = s*rnd.randn(n,2)\n r = np.cumsum(p,axis=0)\n x = r[:,0]\n y = r[:,1]\n plt.plot(x,y)\n plt.axis('equal');\n```\n\n\n```python\nplt.figure(figsize=(4,4))\nrandwalk(1000,1)\n```\n\n\n```python\nplt.figure(figsize=(8,8))\nx = np.linspace(0,6*np.pi,100);\n\nplt.subplot(2,2,1)\nplt.plot(x,np.sin(x),'r')\n\nplt.subplot(2,2,2)\nplt.plot(x,np.cos(x))\n\nplt.subplot(2,2,3)\nplt.plot(x,np.sin(2*x))\n\nplt.subplot(2,2,4)\nplt.plot(x,np.cos(2*x),'g');\n```\n\n\n```python\nx,y = np.mgrid[-3:3:0.2,-3:3:0.2]\n\nz = x**2-y**2-1\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\n\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_surface(x,y,x**2-y**2, cmap=cm.coolwarm, linewidth=0.5, rstride=2, cstride=2);\n```\n\n\n```python\nplt.figure(figsize=(6,6))\nplt.contour(x,y, z , colors=['k']);\nplt.axis('equal');\n```\n\n### Animaciones\n\n\n```python\n# si se produce un error:\n# conda install -c menpo ffmpeg\n\nfrom matplotlib import animation, rc\nfrom IPython.display import HTML\nrc('animation', html='html5')\n```\n\n\n```python\nx = np.linspace(0,2,100)\n\ndef wave(lam,freq,x,t):\n return 1*np.sin(2*np.pi*(x/lam - t*freq))\n```\n\n\n```python\nfig, ax = plt.subplots()\nplt.grid()\nplt.title('onda viajera')\nplt.xlabel('x');\nplt.close();\nax.set_xlim(( 0, 2))\nax.set_ylim((-1.1, 1.1))\n\nline1, = ax.plot([], [], '-')\n#line2, = ax.plot([], [], '.', markerSize=20)\n\nlam = 0.8\nfreq = 1/4\n\ndef animate(i):\n t = i/25\n line1.set_data(x,wave(lam,freq,x,t))\n #line2.set_data(1,f(lam,freq,1,t))\n return ()\n\nanimation.FuncAnimation(fig, animate, frames=100, interval=1000/25, blit=True)\n```\n\n\n\n\n\n\n\n\n### Data frames\n\nEl módulo `pandas` proporciona el tipo \"dataframe\", muy utilizado en análisis de datos. Permite leer conjuntos de datos almacenados en archivos que pueden estar incluso en una máquina remota.\n\n\n```python\nimport pandas as pd\n\ndf = pd.read_table('https://robot.inf.um.es/material/data/ConstanteHubbleDatos-1.txt', sep='\\s+', comment='#')\ndf\n```\n\n\n\n\n\n\n
\n \n \n V(km/s) \n Redshift \n Magnitud \n \n \n \n \n 0 \n 18287 \n 0.060998 \n 17.62 \n \n \n 1 \n 5691 \n 0.018983 \n 15.00 \n \n \n 2 \n 26382 \n 0.088000 \n 18.59 \n \n \n 3 \n 5996 \n 0.020000 \n 15.54 \n \n \n 4 \n 19202 \n 0.064051 \n 15.30 \n \n \n 5 \n 23684 \n 0.079000 \n 16.56 \n \n \n 6 \n 11702 \n 0.039034 \n 17.14 \n \n \n 7 \n 17284 \n 0.057653 \n 13.50 \n \n \n 8 \n 13491 \n 0.045000 \n 17.80 \n \n \n 9 \n 10566 \n 0.035244 \n 15.25 \n \n \n 10 \n 14718 \n 0.049094 \n 15.60 \n \n \n 11 \n 13491 \n 0.045000 \n 14.52 \n \n \n 12 \n 16325 \n 0.054453 \n 15.30 \n \n \n 13 \n 20686 \n 0.069000 \n 16.80 \n \n \n 14 \n 1808 \n 0.006031 \n 11.16 \n \n \n 15 \n 7603 \n 0.025361 \n 15.18 \n \n \n 16 \n 1018 \n 0.003395 \n 12.24 \n \n \n 17 \n 321 \n 0.001071 \n 13.00 \n \n \n 18 \n 3106 \n 0.010360 \n 12.49 \n \n \n 19 \n 9426 \n 0.031442 \n 14.53 \n \n \n 20 \n 7464 \n 0.024897 \n 15.21 \n \n \n 21 \n 15143 \n 0.050512 \n 17.40 \n \n \n 22 \n 407 \n 0.001358 \n 10.87 \n \n \n 23 \n 7257 \n 0.024207 \n 14.60 \n \n \n 24 \n 9193 \n 0.030664 \n 15.10 \n \n \n 25 \n 12137 \n 0.040485 \n 14.75 \n \n \n 26 \n 4264 \n 0.014224 \n 14.98 \n \n \n 27 \n 4381 \n 0.014615 \n 14.15 \n \n \n 28 \n 22484 \n 0.075000 \n 17.43 \n \n \n 29 \n 15162 \n 0.050575 \n 16.50 \n \n \n 30 \n 30000 \n 0.101000 \n 18.90 \n \n \n 31 \n 12981 \n 0.043300 \n 15.23 \n \n \n 32 \n 8803 \n 0.029364 \n 14.90 \n \n \n
\n
\nand .\n\nThe first network created below is similar to the previous network,\nbut it replaces the SimpleRNN layers with LSTM layers. The second\nnetwork below has two hidden layers made up of GRUs, which are\npreceeded by two dense (feeddorward) neural network layers. These\ndense layers \"preprocess\" the data before it reaches the recurrent\nlayers. This architecture has been shown to improve the performance\nof recurrent neural networks (see the link above and also\n.\n\n\n```python\ndef lstm_2layers(length_of_sequences, batch_size = None, stateful = False):\n \"\"\"\n Inputs:\n length_of_sequences (an int): the number of y values in \"x data\". This is determined\n when the data is formatted\n batch_size (an int): Default value is None. See Keras documentation of SimpleRNN.\n stateful (a boolean): Default value is False. See Keras documentation of SimpleRNN.\n Returns:\n model (a Keras model): The recurrent neural network that is built and compiled by this\n method\n Builds and compiles a recurrent neural network with two LSTM hidden layers and returns the model.\n \"\"\"\n # Number of neurons on the input/output layer and the number of neurons in the hidden layer\n in_out_neurons = 1\n hidden_neurons = 250\n # Input Layer\n inp = Input(batch_shape=(batch_size, \n length_of_sequences, \n in_out_neurons)) \n # Hidden layers (in this case they are LSTM layers instead if SimpleRNN layers)\n rnn= LSTM(hidden_neurons, \n return_sequences=True,\n stateful = stateful,\n name=\"RNN\", use_bias=True, activation='tanh')(inp)\n rnn1 = LSTM(hidden_neurons, \n return_sequences=False,\n stateful = stateful,\n name=\"RNN1\", use_bias=True, activation='tanh')(rnn)\n # Output layer\n dens = Dense(in_out_neurons,name=\"dense\")(rnn1)\n # Define the midel\n model = Model(inputs=[inp],outputs=[dens])\n # Compile the model\n model.compile(loss='mean_squared_error', optimizer='adam') \n # Return the model\n return model\n\ndef dnn2_gru2(length_of_sequences, batch_size = None, stateful = False):\n \"\"\"\n Inputs:\n length_of_sequences (an int): the number of y values in \"x data\". This is determined\n when the data is formatted\n batch_size (an int): Default value is None. See Keras documentation of SimpleRNN.\n stateful (a boolean): Default value is False. See Keras documentation of SimpleRNN.\n Returns:\n model (a Keras model): The recurrent neural network that is built and compiled by this\n method\n Builds and compiles a recurrent neural network with four hidden layers (two dense followed by\n two GRU layers) and returns the model.\n \"\"\" \n # Number of neurons on the input/output layers and hidden layers\n in_out_neurons = 1\n hidden_neurons = 250\n # Input layer\n inp = Input(batch_shape=(batch_size, \n length_of_sequences, \n in_out_neurons)) \n # Hidden Dense (feedforward) layers\n dnn = Dense(hidden_neurons/2, activation='relu', name='dnn')(inp)\n dnn1 = Dense(hidden_neurons/2, activation='relu', name='dnn1')(dnn)\n # Hidden GRU layers\n rnn1 = GRU(hidden_neurons, \n return_sequences=True,\n stateful = stateful,\n name=\"RNN1\", use_bias=True)(dnn1)\n rnn = GRU(hidden_neurons, \n return_sequences=False,\n stateful = stateful,\n name=\"RNN\", use_bias=True)(rnn1)\n # Output layer\n dens = Dense(in_out_neurons,name=\"dense\")(rnn)\n # Define the model\n model = Model(inputs=[inp],outputs=[dens])\n # Compile the mdoel\n model.compile(loss='mean_squared_error', optimizer='adam') \n # Return the model\n return model\n\n# Check to make sure the data set is complete\nassert len(X_tot) == len(y_tot)\n\n# This is the number of points that will be used in as the training data\ndim=12\n\n# Separate the training data from the whole data set\nX_train = X_tot[:dim]\ny_train = y_tot[:dim]\n\n\n# Generate the training data for the RNN, using a sequence of 2\nrnn_input, rnn_training = format_data(y_train, 2)\n\n\n# Create a recurrent neural network in Keras and produce a summary of the \n# machine learning model\n# Change the method name to reflect which network you want to use\nmodel = dnn2_gru2(length_of_sequences = 2)\nmodel.summary()\n\n# Start the timer. Want to time training+testing\nstart = timer()\n# Fit the model using the training data genenerated above using 150 training iterations and a 5%\n# validation split. Setting verbose to True prints information about each training iteration.\nhist = model.fit(rnn_input, rnn_training, batch_size=None, epochs=150, \n verbose=True,validation_split=0.05)\n\n\n# This section plots the training loss and the validation loss as a function of training iteration.\n# This is not required for analyzing the couple cluster data but can help determine if the network is\n# being overtrained.\nfor label in [\"loss\",\"val_loss\"]:\n plt.plot(hist.history[label],label=label)\n\nplt.ylabel(\"loss\")\nplt.xlabel(\"epoch\")\nplt.title(\"The final validation loss: {}\".format(hist.history[\"val_loss\"][-1]))\nplt.legend()\nplt.show()\n\n# Use the trained neural network to predict more points of the data set\ntest_rnn(X_tot, y_tot, X_tot[0], X_tot[dim-1])\n# Stop the timer and calculate the total time needed.\nend = timer()\nprint('Time: ', end-start)\n\n\n# ### Training Recurrent Neural Networks in the Standard Way (i.e. learning the relationship between the X and Y data)\n# \n# Finally, comparing the performace of a recurrent neural network using the standard data formatting to the performance of the network with time sequence data formatting shows the benefit of this type of data formatting with extrapolation.\n\n# Check to make sure the data set is complete\nassert len(X_tot) == len(y_tot)\n\n# This is the number of points that will be used in as the training data\ndim=12\n\n# Separate the training data from the whole data set\nX_train = X_tot[:dim]\ny_train = y_tot[:dim]\n\n# Reshape the data for Keras specifications\nX_train = X_train.reshape((dim, 1))\ny_train = y_train.reshape((dim, 1))\n\n\n# Create a recurrent neural network in Keras and produce a summary of the \n# machine learning model\n# Set the sequence length to 1 for regular data formatting \nmodel = rnn(length_of_sequences = 1)\nmodel.summary()\n\n# Start the timer. Want to time training+testing\nstart = timer()\n# Fit the model using the training data genenerated above using 150 training iterations and a 5%\n# validation split. Setting verbose to True prints information about each training iteration.\nhist = model.fit(X_train, y_train, batch_size=None, epochs=150, \n verbose=True,validation_split=0.05)\n\n\n# This section plots the training loss and the validation loss as a function of training iteration.\n# This is not required for analyzing the couple cluster data but can help determine if the network is\n# being overtrained.\nfor label in [\"loss\",\"val_loss\"]:\n plt.plot(hist.history[label],label=label)\n\nplt.ylabel(\"loss\")\nplt.xlabel(\"epoch\")\nplt.title(\"The final validation loss: {}\".format(hist.history[\"val_loss\"][-1]))\nplt.legend()\nplt.show()\n\n# Use the trained neural network to predict the remaining data points\nX_pred = X_tot[dim:]\nX_pred = X_pred.reshape((len(X_pred), 1))\ny_model = model.predict(X_pred)\ny_pred = np.concatenate((y_tot[:dim], y_model.flatten()))\n\n# Plot the known data set and the predicted data set. The red box represents the region that was used\n# for the training data.\nfig, ax = plt.subplots()\nax.plot(X_tot, y_tot, label=\"true\", linewidth=3)\nax.plot(X_tot, y_pred, 'g-.',label=\"predicted\", linewidth=4)\nax.legend()\n# Created a red region to represent the points used in the training data.\nax.axvspan(X_tot[0], X_tot[dim], alpha=0.25, color='red')\nplt.show()\n\n# Stop the timer and calculate the total time needed.\nend = timer()\nprint('Time: ', end-start)\n```\n\n## Generative Models\n\n**Generative models** describe a class of statistical models that are a contrast\nto **discriminative models**. Informally we say that generative models can\ngenerate new data instances while discriminative models discriminate between\ndifferent kinds of data instances. A generative model could generate new photos\nof animals that look like 'real' animals while a discriminative model could tell\na dog from a cat. More formally, given a data set $x$ and a set of labels /\ntargets $y$. Generative models capture the joint probability $p(x, y)$, or\njust $p(x)$ if there are no labels, while discriminative models capture the\nconditional probability $p(y | x)$. Discriminative models generally try to draw\nboundaries in the data space (often high dimensional), while generative models\ntry to model how data is placed throughout the space.\n\n**Note**: this material is thanks to Linus Ekstrøm.\n\n## Generative Adversarial Networks\n\n**Generative Adversarial Networks** are a type of unsupervised machine learning\nalgorithm proposed by [Goodfellow et. al](https://arxiv.org/pdf/1406.2661.pdf)\nin 2014 (short and good article).\n\nThe simplest formulation of\nthe model is based on a game theoretic approach, *zero sum game*, where we pit\ntwo neural networks against one another. We define two rival networks, one\ngenerator $g$, and one discriminator $d$. The generator directly produces\nsamples\n\n\n
\n\n$$\n\\begin{equation}\n x = g(z; \\theta^{(g)})\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\n## Discriminator\nThe discriminator attempts to distinguish between samples drawn from the\ntraining data and samples drawn from the generator. In other words, it tries to\ntell the difference between the fake data produced by $g$ and the actual data\nsamples we want to do prediction on. The discriminator outputs a probability\nvalue given by\n\n\n
\n\n$$\n\\begin{equation}\n d(x; \\theta^{(d)})\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nindicating the probability that $x$ is a real training example rather than a\nfake sample the generator has generated. The simplest way to formulate the\nlearning process in a generative adversarial network is a zero-sum game, in\nwhich a function\n\n\n
\n\n$$\n\\begin{equation}\n v(\\theta^{(g)}, \\theta^{(d)})\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\ndetermines the reward for the discriminator, while the generator gets the\nconjugate reward\n\n\n
\n\n$$\n\\begin{equation}\n -v(\\theta^{(g)}, \\theta^{(d)})\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\n## Learning Process\n\nDuring learning both of the networks maximize their own reward function, so that\nthe generator gets better and better at tricking the discriminator, while the\ndiscriminator gets better and better at telling the difference between the fake\nand real data. The generator and discriminator alternate on which one trains at\none time (i.e. for one epoch). In other words, we keep the generator constant\nand train the discriminator, then we keep the discriminator constant to train\nthe generator and repeat. It is this back and forth dynamic which lets GANs\ntackle otherwise intractable generative problems. As the generator improves with\n training, the discriminator's performance gets worse because it cannot easily\n tell the difference between real and fake. If the generator ends up succeeding\n perfectly, the the discriminator will do no better than random guessing i.e.\n 50\\%. This progression in the training poses a problem for the convergence\n criteria for GANs. The discriminator feedback gets less meaningful over time,\n if we continue training after this point then the generator is effectively\n training on junk data which can undo the learning up to that point. Therefore,\n we stop training when the discriminator starts outputting $1/2$ everywhere.\n\n## More about the Learning Process\n\nAt convergence we have\n\n\n
\n\n$$\n\\begin{equation}\n g^* = \\underset{g}{\\mathrm{argmin}}\\hspace{2pt}\n \\underset{d}{\\mathrm{max}}v(\\theta^{(g)}, \\theta^{(d)})\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\nThe default choice for $v$ is\n\n\n
\n\n$$\n\\begin{equation}\n v(\\theta^{(g)}, \\theta^{(d)}) = \\mathbb{E}_{x\\sim p_\\mathrm{data}}\\log d(x)\n + \\mathbb{E}_{x\\sim p_\\mathrm{model}}\n \\log (1 - d(x))\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\nThe main motivation for the design of GANs is that the learning process requires\nneither approximate inference (variational autoencoders for example) nor\napproximation of a partition function. In the case where\n\n\n
\n\n$$\n\\begin{equation}\n \\underset{d}{\\mathrm{max}}v(\\theta^{(g)}, \\theta^{(d)})\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nis convex in $\\theta^{(g)} then the procedure is guaranteed to converge and is\nasymptotically consistent\n( [Seth Lloyd on QuGANs](https://arxiv.org/pdf/1804.09139.pdf) ).\n\n## Additional References\nThis is in\ngeneral not the case and it is possible to get situations where the training\nprocess never converges because the generator and discriminator chase one\nanother around in the parameter space indefinitely. A much deeper discussion on\nthe currently open research problem of GAN convergence is available\n[here](https://www.deeplearningbook.org/contents/generative_models.html). To\nanyone interested in learning more about GANs it is a highly recommended read.\nDirect quote: \"In this best-performing formulation, the generator aims to\nincrease the log probability that the discriminator makes a mistake, rather than\naiming to decrease the log probability that the discriminator makes the correct\nprediction.\" [Another interesting read](https://arxiv.org/abs/1701.00160)\n\n## Writing Our First Generative Adversarial Network\nLet us now move on to actually implementing a GAN in tensorflow. We will study\nthe performance of our GAN on the MNIST dataset. This code is based on and\nadapted from the\n[google tutorial](https://www.tensorflow.org/tutorials/generative/dcgan)\n\nFirst we import our libraries\n\n\n```python\nimport os\nimport time\nimport numpy as np\nimport tensorflow as tf\nimport matplotlib.pyplot as plt\nfrom tensorflow.keras import layers\nfrom tensorflow.keras.utils import plot_model\n```\n\nNext we define our hyperparameters and import our data the usual way\n\n\n```python\nBUFFER_SIZE = 60000\nBATCH_SIZE = 256\nEPOCHS = 30\n\ndata = tf.keras.datasets.mnist.load_data()\n(train_images, train_labels), (test_images, test_labels) = data\ntrain_images = np.reshape(train_images, (train_images.shape[0],\n 28,\n 28,\n 1)).astype('float32')\n\n# we normalize between -1 and 1\ntrain_images = (train_images - 127.5) / 127.5\ntraining_dataset = tf.data.Dataset.from_tensor_slices(\n train_images).shuffle(BUFFER_SIZE).batch(BATCH_SIZE)\n```\n\n## MNIST and GANs\n\nLet's have a quick look\n\n\n```python\nplt.imshow(train_images[0], cmap='Greys')\nplt.show()\n```\n\nNow we define our two models. This is where the 'magic' happens. There are a\nhuge amount of possible formulations for both models. A lot of engineering and\ntrial and error can be done here to try to produce better performing models. For\nmore advanced GANs this is by far the step where you can 'make or break' a\nmodel.\n\nWe start with the generator. As stated in the introductory text the generator\n$g$ upsamples from a random sample to the shape of what we want to predict. In\nour case we are trying to predict MNIST images ($28\\times 28$ pixels).\n\n\n```python\ndef generator_model():\n \"\"\"\n The generator uses upsampling layers tf.keras.layers.Conv2DTranspose() to\n produce an image from a random seed. We start with a Dense layer taking this\n random sample as an input and subsequently upsample through multiple\n convolutional layers.\n \"\"\"\n\n # we define our model\n model = tf.keras.Sequential()\n\n\n # adding our input layer. Dense means that every neuron is connected and\n # the input shape is the shape of our random noise. The units need to match\n # in some sense the upsampling strides to reach our desired output shape.\n # we are using 100 random numbers as our seed\n model.add(layers.Dense(units=7*7*BATCH_SIZE,\n use_bias=False,\n input_shape=(100, )))\n # we normalize the output form the Dense layer\n model.add(layers.BatchNormalization())\n # and add an activation function to our 'layer'. LeakyReLU avoids vanishing\n # gradient problem\n model.add(layers.LeakyReLU())\n model.add(layers.Reshape((7, 7, BATCH_SIZE)))\n assert model.output_shape == (None, 7, 7, BATCH_SIZE)\n # even though we just added four keras layers we think of everything above\n # as 'one' layer\n\n # next we add our upscaling convolutional layers\n model.add(layers.Conv2DTranspose(filters=128,\n kernel_size=(5, 5),\n strides=(1, 1),\n padding='same',\n use_bias=False))\n model.add(layers.BatchNormalization())\n model.add(layers.LeakyReLU())\n assert model.output_shape == (None, 7, 7, 128)\n\n model.add(layers.Conv2DTranspose(filters=64,\n kernel_size=(5, 5),\n strides=(2, 2),\n padding='same',\n use_bias=False))\n model.add(layers.BatchNormalization())\n model.add(layers.LeakyReLU())\n assert model.output_shape == (None, 14, 14, 64)\n\n model.add(layers.Conv2DTranspose(filters=1,\n kernel_size=(5, 5),\n strides=(2, 2),\n padding='same',\n use_bias=False,\n activation='tanh'))\n assert model.output_shape == (None, 28, 28, 1)\n\n return model\n```\n\nAnd there we have our 'simple' generator model. Now we move on to defining our\ndiscriminator model $d$, which is a convolutional neural network based image\nclassifier.\n\n\n```python\ndef discriminator_model():\n \"\"\"\n The discriminator is a convolutional neural network based image classifier\n \"\"\"\n\n # we define our model\n model = tf.keras.Sequential()\n model.add(layers.Conv2D(filters=64,\n kernel_size=(5, 5),\n strides=(2, 2),\n padding='same',\n input_shape=[28, 28, 1]))\n model.add(layers.LeakyReLU())\n # adding a dropout layer as you do in conv-nets\n model.add(layers.Dropout(0.3))\n\n\n model.add(layers.Conv2D(filters=128,\n kernel_size=(5, 5),\n strides=(2, 2),\n padding='same'))\n model.add(layers.LeakyReLU())\n # adding a dropout layer as you do in conv-nets\n model.add(layers.Dropout(0.3))\n\n model.add(layers.Flatten())\n model.add(layers.Dense(1))\n\n return model\n```\n\n## Other Models\nLet us take a look at our models. **Note**: double click images for bigger view.\n\n\n```python\ngenerator = generator_model()\nplot_model(generator, show_shapes=True, rankdir='LR')\n```\n\n\n```python\ndiscriminator = discriminator_model()\nplot_model(discriminator, show_shapes=True, rankdir='LR')\n```\n\nNext we need a few helper objects we will use in training\n\n\n```python\ncross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\ngenerator_optimizer = tf.keras.optimizers.Adam(1e-4)\ndiscriminator_optimizer = tf.keras.optimizers.Adam(1e-4)\n```\n\nThe first object, *cross_entropy* is our loss function and the two others are\nour optimizers. Notice we use the same learning rate for both $g$ and $d$. This\nis because they need to improve their accuracy at approximately equal speeds to\nget convergence (not necessarily exactly equal). Now we define our loss\nfunctions\n\n\n```python\ndef generator_loss(fake_output):\n loss = cross_entropy(tf.ones_like(fake_output), fake_output)\n\n return loss\n```\n\n\n```python\ndef discriminator_loss(real_output, fake_output):\n real_loss = cross_entropy(tf.ones_like(real_output), real_output)\n fake_loss = cross_entropy(tf.zeros_liks(fake_output), fake_output)\n total_loss = real_loss + fake_loss\n\n return total_loss\n```\n\nNext we define a kind of seed to help us compare the learning process over\nmultiple training epochs.\n\n\n```python\nnoise_dimension = 100\nn_examples_to_generate = 16\nseed_images = tf.random.normal([n_examples_to_generate, noise_dimension])\n```\n\n## Training Step\n\nNow we have everything we need to define our training step, which we will apply\nfor every step in our training loop. Notice the @tf.function flag signifying\nthat the function is tensorflow 'compiled'. Removing this flag doubles the\ncomputation time.\n\n\n```python\n@tf.function\ndef train_step(images):\n noise = tf.random.normal([BATCH_SIZE, noise_dimension])\n\n with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n generated_images = generator(noise, training=True)\n\n real_output = discriminator(images, training=True)\n fake_output = discriminator(generated_images, training=True)\n\n gen_loss = generator_loss(fake_output)\n disc_loss = discriminator_loss(real_output, fake_output)\n\n gradients_of_generator = gen_tape.gradient(gen_loss,\n generator.trainable_variables)\n gradients_of_discriminator = disc_tape.gradient(disc_loss,\n discriminator.trainable_variables)\n generator_optimizer.apply_gradients(zip(gradients_of_generator,\n generator.trainable_variables))\n discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator,\n discriminator.trainable_variables))\n\n return gen_loss, disc_loss\n```\n\nNext we define a helper function to produce an output over our training epochs\nto see the predictive progression of our generator model. **Note**: I am including\nthis code here, but comment it out in the training loop.\n\n\n```python\ndef generate_and_save_images(model, epoch, test_input):\n # we're making inferences here\n predictions = model(test_input, training=False)\n\n fig = plt.figure(figsize=(4, 4))\n\n for i in range(predictions.shape[0]):\n plt.subplot(4, 4, i+1)\n plt.imshow(predictions[i, :, :, 0] * 127.5 + 127.5, cmap='gray')\n plt.axis('off')\n\n plt.savefig(f'./images_from_seed_images/image_at_epoch_{str(epoch).zfill(3)}.png')\n plt.close()\n #plt.show()\n```\n\n## Checkpoints\nSetting up checkpoints to periodically save our model during training so that\neverything is not lost even if the program were to somehow terminate while\ntraining.\n\n\n```python\n# Setting up checkpoints to save model during training\ncheckpoint_dir = './training_checkpoints'\ncheckpoint_prefix = os.path.join(checkpoint_dir, 'ckpt')\ncheckpoint = tf.train.Checkpoint(generator_optimizer=generator_optimizer,\n discriminator_optimizer=discriminator_optimizer,\n generator=generator,\n discriminator=discriminator)\n```\n\nNow we define our training loop\n\n\n```python\ndef train(dataset, epochs):\n generator_loss_list = []\n discriminator_loss_list = []\n\n for epoch in range(epochs):\n start = time.time()\n\n for image_batch in dataset:\n gen_loss, disc_loss = train_step(image_batch)\n generator_loss_list.append(gen_loss.numpy())\n discriminator_loss_list.append(disc_loss.numpy())\n\n #generate_and_save_images(generator, epoch + 1, seed_images)\n\n if (epoch + 1) % 15 == 0:\n checkpoint.save(file_prefix=checkpoint_prefix)\n\n print(f'Time for epoch {epoch} is {time.time() - start}')\n\n #generate_and_save_images(generator, epochs, seed_images)\n\n loss_file = './data/lossfile.txt'\n with open(loss_file, 'w') as outfile:\n outfile.write(str(generator_loss_list))\n outfile.write('\\n')\n outfile.write('\\n')\n outfile.write(str(discriminator_loss_list))\n outfile.write('\\n')\n outfile.write('\\n')\n```\n\nTo train simply call this function. **Warning**: this might take a long time so\nthere is a folder of a pretrained network already included in the repository.\n\n\n```python\ntrain(train_dataset, EPOCHS)\n```\n\nAnd here is the result of training our model for 100 epochs\n\n\n\n\n\n```python\nfrom IPython.display import HTML\n_s = \"\"\"\n
\n\"\"\"\nHTML(_s)\n```\n\n\n\nNow to avoid having to train and everything, which will take a while depending\non your computer setup we now load in the model which produced the above gif.\n\n\n```python\ncheckpoint.restore(tf.train.latest_checkpoint(checkpoint_dir))\nrestored_generator = checkpoint.generator\nrestored_discriminator = checkpoint.discriminator\n\nprint(restored_generator)\nprint(restored_discriminator)\n```\n\n## Exploring the Latent Space\n\nWe have successfully loaded in our latest model. Let us now play around a bit\nand see what kind of things we can learn about this model. Our generator takes\nan array of 100 numbers. One idea can be to try to systematically change our\ninput. Let us try and see what we get\n\n\n```python\ndef generate_latent_points(number=100, scale_means=1, scale_stds=1):\n latent_dim = 100\n means = scale_means * tf.linspace(-1, 1, num=latent_dim)\n stds = scale_stds * tf.linspace(-1, 1, num=latent_dim)\n latent_space_value_range = tf.random.normal([number, latent_dim],\n means,\n stds,\n dtype=tf.float64)\n\n return latent_space_value_range\n\ndef generate_images(latent_points):\n # notice we set training to false because we are making inferences\n generated_images = restored_generator.predict(latent_points)\n\n return generated_images\n```\n\n\n```python\ndef plot_result(generated_images, number=100):\n # obviously this assumes sqrt number is an int\n fig, axs = plt.subplots(int(np.sqrt(number)), int(np.sqrt(number)),\n figsize=(10, 10))\n\n for i in range(int(np.sqrt(number))):\n for j in range(int(np.sqrt(number))):\n axs[i, j].imshow(generated_images[i*j], cmap='Greys')\n axs[i, j].axis('off')\n\n plt.show()\n```\n\n\n```python\ngenerated_images = generate_images(generate_latent_points())\nplot_result(generated_images)\n```\n\n## Getting Results\nWe see that the generator generates images that look like MNIST\nnumbers: $1, 4, 7, 9$. Let's try to tweak it a bit more to see if we are able\nto generate a similar plot where we generate every MNIST number. Let us now try\nto 'move' a bit around in the latent space. **Note**: decrease the plot number if\nthese following cells take too long to run on your computer.\n\n\n```python\nplot_number = 225\n\ngenerated_images = generate_images(generate_latent_points(number=plot_number,\n scale_means=5,\n scale_stds=1))\nplot_result(generated_images, number=plot_number)\n\ngenerated_images = generate_images(generate_latent_points(number=plot_number,\n scale_means=-5,\n scale_stds=1))\nplot_result(generated_images, number=plot_number)\n\ngenerated_images = generate_images(generate_latent_points(number=plot_number,\n scale_means=1,\n scale_stds=5))\nplot_result(generated_images, number=plot_number)\n```\n\nAgain, we have found something interesting. *Moving* around using our means\ntakes us from digit to digit, while *moving* around using our standard\ndeviations seem to increase the number of different digits! In the last image\nabove, we can barely make out every MNIST digit. Let us make on last plot using\nthis information by upping the standard deviation of our Gaussian noises.\n\n\n```python\nplot_number = 400\ngenerated_images = generate_images(generate_latent_points(number=plot_number,\n scale_means=1,\n scale_stds=10))\nplot_result(generated_images, number=plot_number)\n```\n\nA pretty cool result! We see that our generator indeed has learned a\ndistribution which qualitatively looks a whole lot like the MNIST dataset.\n\n## Interpolating Between MNIST Digits\nAnother interesting way to explore the latent space of our generator model is by\ninterpolating between the MNIST digits. This section is largely based on\n[this excellent blogpost](https://machinelearningmastery.com/how-to-interpolate-and-perform-vector-arithmetic-with-faces-using-a-generative-adversarial-network/)\nby Jason Brownlee.\n\nSo let us start by defining a function to interpolate between two points in the\nlatent space.\n\n\n```python\ndef interpolation(point_1, point_2, n_steps=10):\n ratios = np.linspace(0, 1, num=n_steps)\n vectors = []\n for i, ratio in enumerate(ratios):\n vectors.append(((1.0 - ratio) * point_1 + ratio * point_2))\n\n return tf.stack(vectors)\n```\n\nNow we have all we need to do our interpolation analysis.\n\n\n```python\nplot_number = 100\nlatent_points = generate_latent_points(number=plot_number)\nresults = None\nfor i in range(0, 2*np.sqrt(plot_number), 2):\n interpolated = interpolation(latent_points[i], latent_points[i+1])\n generated_images = generate_images(interpolated)\n\n if results is None:\n results = generated_images\n else:\n results = tf.stack((results, generated_images))\n\nplot_results(results, plot_number)\n```\n\n## Basic ideas of the Principal Component Analysis (PCA)\n\nThe principal component analysis deals with the problem of fitting a\nlow-dimensional affine subspace $S$ of dimension $d$ much smaller than\nthe total dimension $D$ of the problem at hand (our data\nset). Mathematically it can be formulated as a statistical problem or\na geometric problem. In our discussion of the theorem for the\nclassical PCA, we will stay with a statistical approach. \nHistorically, the PCA was first formulated in a statistical setting in order to estimate the principal component of a multivariate random variable.\n\nWe have a data set defined by a design/feature matrix $\\boldsymbol{X}$ (see below for its definition) \n* Each data point is determined by $p$ extrinsic (measurement) variables\n\n* We may want to ask the following question: Are there fewer intrinsic variables (say $d << p$) that still approximately describe the data?\n\n* If so, these intrinsic variables may tell us something important and finding these intrinsic variables is what dimension reduction methods do. \n\nA good read is for example [Vidal, Ma and Sastry](https://www.springer.com/gp/book/9780387878102).\n\n## Introducing the Covariance and Correlation functions\n\nBefore we discuss the PCA theorem, we need to remind ourselves about\nthe definition of the covariance and the correlation function. These are quantities \n\nSuppose we have defined two vectors\n$\\hat{x}$ and $\\hat{y}$ with $n$ elements each. The covariance matrix $\\boldsymbol{C}$ is defined as\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x},\\boldsymbol{y}] = \\begin{bmatrix} \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{x}] & \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] \\\\\n \\mathrm{cov}[\\boldsymbol{y},\\boldsymbol{x}] & \\mathrm{cov}[\\boldsymbol{y},\\boldsymbol{y}] \\\\\n \\end{bmatrix},\n$$\n\nwhere for example\n\n$$\n\\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] =\\frac{1}{n} \\sum_{i=0}^{n-1}(x_i- \\overline{x})(y_i- \\overline{y}).\n$$\n\nWith this definition and recalling that the variance is defined as\n\n$$\n\\mathrm{var}[\\boldsymbol{x}]=\\frac{1}{n} \\sum_{i=0}^{n-1}(x_i- \\overline{x})^2,\n$$\n\nwe can rewrite the covariance matrix as\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x},\\boldsymbol{y}] = \\begin{bmatrix} \\mathrm{var}[\\boldsymbol{x}] & \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] \\\\\n \\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}] & \\mathrm{var}[\\boldsymbol{y}] \\\\\n \\end{bmatrix}.\n$$\n\n## More on the covariance\nThe covariance takes values between zero and infinity and may thus\nlead to problems with loss of numerical precision for particularly\nlarge values. It is common to scale the covariance matrix by\nintroducing instead the correlation matrix defined via the so-called\ncorrelation function\n\n$$\n\\mathrm{corr}[\\boldsymbol{x},\\boldsymbol{y}]=\\frac{\\mathrm{cov}[\\boldsymbol{x},\\boldsymbol{y}]}{\\sqrt{\\mathrm{var}[\\boldsymbol{x}] \\mathrm{var}[\\boldsymbol{y}]}}.\n$$\n\nThe correlation function is then given by values $\\mathrm{corr}[\\boldsymbol{x},\\boldsymbol{y}]\n\\in [-1,1]$. This avoids eventual problems with too large values. We\ncan then define the correlation matrix for the two vectors $\\boldsymbol{x}$\nand $\\boldsymbol{y}$ as\n\n$$\n\\boldsymbol{K}[\\boldsymbol{x},\\boldsymbol{y}] = \\begin{bmatrix} 1 & \\mathrm{corr}[\\boldsymbol{x},\\boldsymbol{y}] \\\\\n \\mathrm{corr}[\\boldsymbol{y},\\boldsymbol{x}] & 1 \\\\\n \\end{bmatrix},\n$$\n\nIn the above example this is the function we constructed using **pandas**.\n\n## Reminding ourselves about Linear Regression\nIn our derivation of the various regression algorithms like **Ordinary Least Squares** or **Ridge regression**\nwe defined the design/feature matrix $\\boldsymbol{X}$ as\n\n$$\n\\boldsymbol{X}=\\begin{bmatrix}\nx_{0,0} & x_{0,1} & x_{0,2}& \\dots & \\dots x_{0,p-1}\\\\\nx_{1,0} & x_{1,1} & x_{1,2}& \\dots & \\dots x_{1,p-1}\\\\\nx_{2,0} & x_{2,1} & x_{2,2}& \\dots & \\dots x_{2,p-1}\\\\\n\\dots & \\dots & \\dots & \\dots \\dots & \\dots \\\\\nx_{n-2,0} & x_{n-2,1} & x_{n-2,2}& \\dots & \\dots x_{n-2,p-1}\\\\\nx_{n-1,0} & x_{n-1,1} & x_{n-1,2}& \\dots & \\dots x_{n-1,p-1}\\\\\n\\end{bmatrix},\n$$\n\nwith $\\boldsymbol{X}\\in {\\mathbb{R}}^{n\\times p}$, with the predictors/features $p$ refering to the column numbers and the\nentries $n$ being the row elements.\nWe can rewrite the design/feature matrix in terms of its column vectors as\n\n$$\n\\boldsymbol{X}=\\begin{bmatrix} \\boldsymbol{x}_0 & \\boldsymbol{x}_1 & \\boldsymbol{x}_2 & \\dots & \\dots & \\boldsymbol{x}_{p-1}\\end{bmatrix},\n$$\n\nwith a given vector\n\n$$\n\\boldsymbol{x}_i^T = \\begin{bmatrix}x_{0,i} & x_{1,i} & x_{2,i}& \\dots & \\dots x_{n-1,i}\\end{bmatrix}.\n$$\n\n## Simple Example\nWith these definitions, we can now rewrite our $2\\times 2$\ncorrelation/covariance matrix in terms of a moe general design/feature\nmatrix $\\boldsymbol{X}\\in {\\mathbb{R}}^{n\\times p}$. This leads to a $p\\times p$\ncovariance matrix for the vectors $\\boldsymbol{x}_i$ with $i=0,1,\\dots,p-1$\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x}] = \\begin{bmatrix}\n\\mathrm{var}[\\boldsymbol{x}_0] & \\mathrm{cov}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] & \\mathrm{cov}[\\boldsymbol{x}_0,\\boldsymbol{x}_2] & \\dots & \\dots & \\mathrm{cov}[\\boldsymbol{x}_0,\\boldsymbol{x}_{p-1}]\\\\\n\\mathrm{cov}[\\boldsymbol{x}_1,\\boldsymbol{x}_0] & \\mathrm{var}[\\boldsymbol{x}_1] & \\mathrm{cov}[\\boldsymbol{x}_1,\\boldsymbol{x}_2] & \\dots & \\dots & \\mathrm{cov}[\\boldsymbol{x}_1,\\boldsymbol{x}_{p-1}]\\\\\n\\mathrm{cov}[\\boldsymbol{x}_2,\\boldsymbol{x}_0] & \\mathrm{cov}[\\boldsymbol{x}_2,\\boldsymbol{x}_1] & \\mathrm{var}[\\boldsymbol{x}_2] & \\dots & \\dots & \\mathrm{cov}[\\boldsymbol{x}_2,\\boldsymbol{x}_{p-1}]\\\\\n\\dots & \\dots & \\dots & \\dots & \\dots & \\dots \\\\\n\\dots & \\dots & \\dots & \\dots & \\dots & \\dots \\\\\n\\mathrm{cov}[\\boldsymbol{x}_{p-1},\\boldsymbol{x}_0] & \\mathrm{cov}[\\boldsymbol{x}_{p-1},\\boldsymbol{x}_1] & \\mathrm{cov}[\\boldsymbol{x}_{p-1},\\boldsymbol{x}_{2}] & \\dots & \\dots & \\mathrm{var}[\\boldsymbol{x}_{p-1}]\\\\\n\\end{bmatrix},\n$$\n\n## The Correlation Matrix\n\nand the correlation matrix\n\n$$\n\\boldsymbol{K}[\\boldsymbol{x}] = \\begin{bmatrix}\n1 & \\mathrm{corr}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] & \\mathrm{corr}[\\boldsymbol{x}_0,\\boldsymbol{x}_2] & \\dots & \\dots & \\mathrm{corr}[\\boldsymbol{x}_0,\\boldsymbol{x}_{p-1}]\\\\\n\\mathrm{corr}[\\boldsymbol{x}_1,\\boldsymbol{x}_0] & 1 & \\mathrm{corr}[\\boldsymbol{x}_1,\\boldsymbol{x}_2] & \\dots & \\dots & \\mathrm{corr}[\\boldsymbol{x}_1,\\boldsymbol{x}_{p-1}]\\\\\n\\mathrm{corr}[\\boldsymbol{x}_2,\\boldsymbol{x}_0] & \\mathrm{corr}[\\boldsymbol{x}_2,\\boldsymbol{x}_1] & 1 & \\dots & \\dots & \\mathrm{corr}[\\boldsymbol{x}_2,\\boldsymbol{x}_{p-1}]\\\\\n\\dots & \\dots & \\dots & \\dots & \\dots & \\dots \\\\\n\\dots & \\dots & \\dots & \\dots & \\dots & \\dots \\\\\n\\mathrm{corr}[\\boldsymbol{x}_{p-1},\\boldsymbol{x}_0] & \\mathrm{corr}[\\boldsymbol{x}_{p-1},\\boldsymbol{x}_1] & \\mathrm{corr}[\\boldsymbol{x}_{p-1},\\boldsymbol{x}_{2}] & \\dots & \\dots & 1\\\\\n\\end{bmatrix},\n$$\n\n## Numpy Functionality\n\nThe Numpy function **np.cov** calculates the covariance elements using\nthe factor $1/(n-1)$ instead of $1/n$ since it assumes we do not have\nthe exact mean values. The following simple function uses the\n**np.vstack** function which takes each vector of dimension $1\\times n$\nand produces a $2\\times n$ matrix $\\boldsymbol{W}$\n\n$$\n\\boldsymbol{W}^T = \\begin{bmatrix} x_0 & y_0 \\\\\n x_1 & y_1 \\\\\n x_2 & y_2\\\\\n \\dots & \\dots \\\\\n x_{n-2} & y_{n-2}\\\\\n x_{n-1} & y_{n-1} & \n \\end{bmatrix},\n$$\n\nwhich in turn is converted into into the $2\\times 2$ covariance matrix\n$\\boldsymbol{C}$ via the Numpy function **np.cov()**. We note that we can also calculate\nthe mean value of each set of samples $\\boldsymbol{x}$ etc using the Numpy\nfunction **np.mean(x)**. We can also extract the eigenvalues of the\ncovariance matrix through the **np.linalg.eig()** function.\n\n\n```python\n# Importing various packages\nimport numpy as np\nn = 100\nx = np.random.normal(size=n)\nprint(np.mean(x))\ny = 4+3*x+np.random.normal(size=n)\nprint(np.mean(y))\nW = np.vstack((x, y))\nC = np.cov(W)\nprint(C)\n```\n\n## Correlation Matrix again\n\nThe previous example can be converted into the correlation matrix by\nsimply scaling the matrix elements with the variances. We should also\nsubtract the mean values for each column. This leads to the following\ncode which sets up the correlations matrix for the previous example in\na more brute force way. Here we scale the mean values for each column of the design matrix, calculate the relevant mean values and variances and then finally set up the $2\\times 2$ correlation matrix (since we have only two vectors).\n\n\n```python\nimport numpy as np\nn = 100\n# define two vectors \nx = np.random.random(size=n)\ny = 4+3*x+np.random.normal(size=n)\n#scaling the x and y vectors \nx = x - np.mean(x)\ny = y - np.mean(y)\nvariance_x = np.sum(x@x)/n\nvariance_y = np.sum(y@y)/n\nprint(variance_x)\nprint(variance_y)\ncov_xy = np.sum(x@y)/n\ncov_xx = np.sum(x@x)/n\ncov_yy = np.sum(y@y)/n\nC = np.zeros((2,2))\nC[0,0]= cov_xx/variance_x\nC[1,1]= cov_yy/variance_y\nC[0,1]= cov_xy/np.sqrt(variance_y*variance_x)\nC[1,0]= C[0,1]\nprint(C)\n```\n\nWe see that the matrix elements along the diagonal are one as they\nshould be and that the matrix is symmetric. Furthermore, diagonalizing\nthis matrix we easily see that it is a positive definite matrix.\n\nThe above procedure with **numpy** can be made more compact if we use **pandas**.\n\n## Using Pandas\n\nWe whow here how we can set up the correlation matrix using **pandas**, as done in this simple code\n\n\n```python\nimport numpy as np\nimport pandas as pd\nn = 10\nx = np.random.normal(size=n)\nx = x - np.mean(x)\ny = 4+3*x+np.random.normal(size=n)\ny = y - np.mean(y)\nX = (np.vstack((x, y))).T\nprint(X)\nXpd = pd.DataFrame(X)\nprint(Xpd)\ncorrelation_matrix = Xpd.corr()\nprint(correlation_matrix)\n```\n\n## And then the Franke Function\n\nWe expand this model to the Franke function discussed above.\n\n\n```python\n# Common imports\nimport numpy as np\nimport pandas as pd\n\n\ndef FrankeFunction(x,y):\n\tterm1 = 0.75*np.exp(-(0.25*(9*x-2)**2) - 0.25*((9*y-2)**2))\n\tterm2 = 0.75*np.exp(-((9*x+1)**2)/49.0 - 0.1*(9*y+1))\n\tterm3 = 0.5*np.exp(-(9*x-7)**2/4.0 - 0.25*((9*y-3)**2))\n\tterm4 = -0.2*np.exp(-(9*x-4)**2 - (9*y-7)**2)\n\treturn term1 + term2 + term3 + term4\n\n\ndef create_X(x, y, n ):\n\tif len(x.shape) > 1:\n\t\tx = np.ravel(x)\n\t\ty = np.ravel(y)\n\n\tN = len(x)\n\tl = int((n+1)*(n+2)/2)\t\t# Number of elements in beta\n\tX = np.ones((N,l))\n\n\tfor i in range(1,n+1):\n\t\tq = int((i)*(i+1)/2)\n\t\tfor k in range(i+1):\n\t\t\tX[:,q+k] = (x**(i-k))*(y**k)\n\n\treturn X\n\n\n# Making meshgrid of datapoints and compute Franke's function\nn = 4\nN = 100\nx = np.sort(np.random.uniform(0, 1, N))\ny = np.sort(np.random.uniform(0, 1, N))\nz = FrankeFunction(x, y)\nX = create_X(x, y, n=n) \n\nXpd = pd.DataFrame(X)\n# subtract the mean values and set up the covariance matrix\nXpd = Xpd - Xpd.mean()\ncovariance_matrix = Xpd.cov()\nprint(covariance_matrix)\n```\n\n 0 1 2 3 4 5 6 7 \\\n 0 0.0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n 1 0.0 0.080122 0.084563 0.083357 0.083273 0.082845 0.076316 0.075428 \n 2 0.0 0.084563 0.089732 0.088853 0.088990 0.088723 0.081699 0.080870 \n 3 0.0 0.083357 0.088853 0.091631 0.092058 0.092059 0.087014 0.086309 \n 4 0.0 0.083273 0.088990 0.092058 0.092622 0.092744 0.087692 0.087067 \n 5 0.0 0.082845 0.088723 0.092059 0.092744 0.092976 0.087958 0.087411 \n 6 0.0 0.076316 0.081699 0.087014 0.087692 0.087958 0.084819 0.084319 \n 7 0.0 0.075428 0.080870 0.086309 0.087067 0.087411 0.084319 0.083882 \n 8 0.0 0.074485 0.079966 0.085511 0.086341 0.086754 0.083715 0.083338 \n 9 0.0 0.073513 0.079017 0.084652 0.085545 0.086023 0.083040 0.082719 \n 10 0.0 0.068473 0.073439 0.080118 0.080888 0.081283 0.079628 0.079273 \n 11 0.0 0.067511 0.072480 0.079180 0.080000 0.080445 0.078823 0.078516 \n 12 0.0 0.066557 0.071524 0.078234 0.079099 0.079591 0.078001 0.077740 \n 13 0.0 0.065618 0.070576 0.077290 0.078195 0.078731 0.077171 0.076953 \n 14 0.0 0.064697 0.069643 0.076353 0.077295 0.077870 0.076340 0.076163 \n \n 8 9 10 11 12 13 14 \n 0 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 \n 1 0.074485 0.073513 0.068473 0.067511 0.066557 0.065618 0.064697 \n 2 0.079966 0.079017 0.073439 0.072480 0.071524 0.070576 0.069643 \n 3 0.085511 0.084652 0.080118 0.079180 0.078234 0.077290 0.076353 \n 4 0.086341 0.085545 0.080888 0.080000 0.079099 0.078195 0.077295 \n 5 0.086754 0.086023 0.081283 0.080445 0.079591 0.078731 0.077870 \n 6 0.083715 0.083040 0.079628 0.078823 0.078001 0.077171 0.076340 \n 7 0.083338 0.082719 0.079273 0.078516 0.077740 0.076953 0.076163 \n 8 0.082852 0.082287 0.078817 0.078107 0.077375 0.076632 0.075882 \n 9 0.082287 0.081774 0.078288 0.077624 0.076936 0.076233 0.075524 \n 10 0.078817 0.078288 0.075877 0.075195 0.074494 0.073780 0.073062 \n 11 0.078107 0.077624 0.075195 0.074556 0.073894 0.073219 0.072537 \n 12 0.077375 0.076936 0.074494 0.073894 0.073271 0.072633 0.071988 \n 13 0.076632 0.076233 0.073780 0.073219 0.072633 0.072032 0.071421 \n 14 0.075882 0.075524 0.073062 0.072537 0.071988 0.071421 0.070843 \n\n\nWe note here that the covariance is zero for the first rows and\ncolumns since all matrix elements in the design matrix were set to one\n(we are fitting the function in terms of a polynomial of degree $n$). We would however not include the intercept\nand wee can simply\ndrop these elements and construct a correlation\nmatrix without them by centering our matrix elements by subtracting the mean of each column.\n\n## Lnks with the Design Matrix\n\nWe can rewrite the covariance matrix in a more compact form in terms of the design/feature matrix $\\boldsymbol{X}$ as\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x}] = \\frac{1}{n}\\boldsymbol{X}^T\\boldsymbol{X}= \\mathbb{E}[\\boldsymbol{X}^T\\boldsymbol{X}].\n$$\n\nTo see this let us simply look at a design matrix $\\boldsymbol{X}\\in {\\mathbb{R}}^{2\\times 2}$\n\n$$\n\\boldsymbol{X}=\\begin{bmatrix}\nx_{00} & x_{01}\\\\\nx_{10} & x_{11}\\\\\n\\end{bmatrix}=\\begin{bmatrix}\n\\boldsymbol{x}_{0} & \\boldsymbol{x}_{1}\\\\\n\\end{bmatrix}.\n$$\n\n## Computing the Expectation Values\n\nIf we then compute the expectation value\n\n$$\n\\mathbb{E}[\\boldsymbol{X}^T\\boldsymbol{X}] = \\frac{1}{n}\\boldsymbol{X}^T\\boldsymbol{X}=\\begin{bmatrix}\nx_{00}^2+x_{01}^2 & x_{00}x_{10}+x_{01}x_{11}\\\\\nx_{10}x_{00}+x_{11}x_{01} & x_{10}^2+x_{11}^2\\\\\n\\end{bmatrix},\n$$\n\nwhich is just\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] = \\boldsymbol{C}[\\boldsymbol{x}]=\\begin{bmatrix} \\mathrm{var}[\\boldsymbol{x}_0] & \\mathrm{cov}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] \\\\\n \\mathrm{cov}[\\boldsymbol{x}_1,\\boldsymbol{x}_0] & \\mathrm{var}[\\boldsymbol{x}_1] \\\\\n \\end{bmatrix},\n$$\n\nwhere we wrote $$\\boldsymbol{C}[\\boldsymbol{x}_0,\\boldsymbol{x}_1] = \\boldsymbol{C}[\\boldsymbol{x}]$$ to indicate that this the covariance of the vectors $\\boldsymbol{x}$ of the design/feature matrix $\\boldsymbol{X}$.\n\nIt is easy to generalize this to a matrix $\\boldsymbol{X}\\in {\\mathbb{R}}^{n\\times p}$.\n\n## Towards the PCA theorem\n\nWe have that the covariance matrix (the correlation matrix involves a simple rescaling) is given as\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x}] = \\frac{1}{n}\\boldsymbol{X}^T\\boldsymbol{X}= \\mathbb{E}[\\boldsymbol{X}^T\\boldsymbol{X}].\n$$\n\nLet us now assume that we can perform a series of orthogonal transformations where we employ some orthogonal matrices $\\boldsymbol{S}$.\nThese matrices are defined as $\\boldsymbol{S}\\in {\\mathbb{R}}^{p\\times p}$ and obey the orthogonality requirements $\\boldsymbol{S}\\boldsymbol{S}^T=\\boldsymbol{S}^T\\boldsymbol{S}=\\boldsymbol{I}$. The matrix can be written out in terms of the column vectors $\\boldsymbol{s}_i$ as $\\boldsymbol{S}=[\\boldsymbol{s}_0,\\boldsymbol{s}_1,\\dots,\\boldsymbol{s}_{p-1}]$ and $\\boldsymbol{s}_i \\in {\\mathbb{R}}^{p}$.\n\nAssume also that there is a transformation $\\boldsymbol{S}^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S}=\\boldsymbol{C}[\\boldsymbol{y}]$ such that the new matrix $\\boldsymbol{C}[\\boldsymbol{y}]$ is diagonal with elements $[\\lambda_0,\\lambda_1,\\lambda_2,\\dots,\\lambda_{p-1}]$. \n\nThat is we have\n\n$$\n\\boldsymbol{C}[\\boldsymbol{y}] = \\mathbb{E}[\\boldsymbol{S}^T\\boldsymbol{X}^T\\boldsymbol{X}T\\boldsymbol{S}]=\\boldsymbol{S}^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S},\n$$\n\nsince the matrix $\\boldsymbol{S}$ is not a data dependent matrix. Multiplying with $\\boldsymbol{S}$ from the left we have\n\n$$\n\\boldsymbol{S}\\boldsymbol{C}[\\boldsymbol{y}] = \\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S},\n$$\n\nand since $\\boldsymbol{C}[\\boldsymbol{y}]$ is diagonal we have for a given eigenvalue $i$ of the covariance matrix that\n\n$$\n\\boldsymbol{S}_i\\lambda_i = \\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{S}_i.\n$$\n\n## More on the PCA Theorem\n\nIn the derivation of the PCA theorem we will assume that the eigenvalues are ordered in descending order, that is\n$\\lambda_0 > \\lambda_1 > \\dots > \\lambda_{p-1}$. \n\nThe eigenvalues tell us then how much we need to stretch the\ncorresponding eigenvectors. Dimensions with large eigenvalues have\nthus large variations (large variance) and define therefore useful\ndimensions. The data points are more spread out in the direction of\nthese eigenvectors. Smaller eigenvalues mean on the other hand that\nthe corresponding eigenvectors are shrunk accordingly and the data\npoints are tightly bunched together and there is not much variation in\nthese specific directions. Hopefully then we could leave it out\ndimensions where the eigenvalues are very small. If $p$ is very large,\nwe could then aim at reducing $p$ to $l << p$ and handle only $l$\nfeatures/predictors.\n\n## The Algorithm before theorem\n\nHere's how we would proceed in setting up the algorithm for the PCA, see also discussion below here. \n* Set up the datapoints for the design/feature matrix $\\boldsymbol{X}$ with $\\boldsymbol{X}\\in {\\mathbb{R}}^{n\\times p}$, with the predictors/features $p$ referring to the column numbers and the entries $n$ being the row elements.\n\n$$\n\\boldsymbol{X}=\\begin{bmatrix}\nx_{0,0} & x_{0,1} & x_{0,2}& \\dots & \\dots x_{0,p-1}\\\\\nx_{1,0} & x_{1,1} & x_{1,2}& \\dots & \\dots x_{1,p-1}\\\\\nx_{2,0} & x_{2,1} & x_{2,2}& \\dots & \\dots x_{2,p-1}\\\\\n\\dots & \\dots & \\dots & \\dots \\dots & \\dots \\\\\nx_{n-2,0} & x_{n-2,1} & x_{n-2,2}& \\dots & \\dots x_{n-2,p-1}\\\\\nx_{n-1,0} & x_{n-1,1} & x_{n-1,2}& \\dots & \\dots x_{n-1,p-1}\\\\\n\\end{bmatrix},\n$$\n\n* Center the data by subtracting the mean value for each column. This leads to a new matrix $\\boldsymbol{X}\\rightarrow \\overline{\\boldsymbol{X}}$.\n\n* Compute then the covariance/correlation matrix $\\mathbb{E}[\\overline{\\boldsymbol{X}}^T\\overline{\\boldsymbol{X}}]$.\n\n* Find the eigenpairs of $\\boldsymbol{C}$ with eigenvalues $[\\lambda_0,\\lambda_1,\\dots,\\lambda_{p-1}]$ and eigenvectors $[\\boldsymbol{s}_0,\\boldsymbol{s}_1,\\dots,\\boldsymbol{s}_{p-1}]$.\n\n* Order the eigenvalue (and the eigenvectors accordingly) in order of decreasing eigenvalues.\n\n* Keep only those $l$ eigenvalues larger than a selected threshold value, discarding thus $p-l$ features since we expect small variations in the data here.\n\n## Writing our own PCA code\n\nWe will use a simple example first with two-dimensional data\ndrawn from a multivariate normal distribution with the following mean and covariance matrix (we have fixed these quantities but will play around with them below):\n\n$$\n\\mu = (-1,2) \\qquad \\Sigma = \\begin{bmatrix} 4 & 2 \\\\\n2 & 2\n\\end{bmatrix}\n$$\n\nNote that the mean refers to each column of data. \nWe will generate $n = 10000$ points $X = \\{ x_1, \\ldots, x_N \\}$ from\nthis distribution, and store them in the $1000 \\times 2$ matrix $\\boldsymbol{X}$. This is our design matrix where we have forced the covariance and mean values to take specific values.\n\n## Implementing it\nThe following Python code aids in setting up the data and writing out the design matrix.\nNote that the function **multivariate** returns also the covariance discussed above and that it is defined by dividing by $n-1$ instead of $n$.\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom IPython.display import display\nn = 10000\nmean = (-1, 2)\ncov = [[10, 0.02], [0.02, 0.05]]\nX = np.random.multivariate_normal(mean, cov, n)\n```\n\nNow we are going to implement the PCA algorithm. We will break it down into various substeps.\n\n## First Step\n\nThe first step of PCA is to compute the sample mean of the data and use it to center the data. Recall that the sample mean is\n\n$$\n\\mu_n = \\frac{1}{n} \\sum_{i=1}^n x_i\n$$\n\nand the mean-centered data $\\bar{X} = \\{ \\bar{x}_1, \\ldots, \\bar{x}_n \\}$ takes the form\n\n$$\n\\bar{x}_i = x_i - \\mu_n.\n$$\n\nWhen you are done with these steps, print out $\\mu_n$ to verify it is\nclose to $\\mu$ and plot your mean centered data to verify it is\ncentered at the origin! \nThe following code elements perform these operations using **pandas** or using our own functionality for doing so. The latter, using **numpy** is rather simple through the **mean()** function.\n\n\n```python\ndf = pd.DataFrame(X)\n# Pandas does the centering for us\ndf = df -df.mean()\n# we center it ourselves\nX_centered = X - X.mean(axis=0)\n```\n\n## Scaling\nAlternatively, we could use the functions we discussed\nearlier for scaling the data set. That is, we could have used the\n**StandardScaler** function in **Scikit-Learn**, a function which ensures\nthat for each feature/predictor we study the mean value is zero and\nthe variance is one (every column in the design/feature matrix). You\nwould then not get the same results, since we divide by the\nvariance. The diagonal covariance matrix elements will then be one,\nwhile the non-diagonal ones need to be divided by $2\\sqrt{2}$ for our\nspecific case.\n\n## Centered Data\n\nNow we are going to use the mean centered data to compute the sample covariance of the data by using the following equation\n\n$$\n\\Sigma_n = \\frac{1}{n-1} \\sum_{i=1}^n \\bar{x}_i^T \\bar{x}_i = \\frac{1}{n-1} \\sum_{i=1}^n (x_i - \\mu_n)^T (x_i - \\mu_n)\n$$\n\nwhere the data points $x_i \\in \\mathbb{R}^p$ (here in this example $p = 2$) are column vectors and $x^T$ is the transpose of $x$.\nWe can write our own code or simply use either the functionaly of **numpy** or that of **pandas**, as follows\n\n\n```python\nprint(df.cov())\nprint(np.cov(X_centered.T))\n```\n\n 0 1\n 0 9.876569 0.022155\n 1 0.022155 0.048984\n [[9.87656905 0.0221551 ]\n [0.0221551 0.04898395]]\n\n\nNote that the way we define the covariance matrix here has a factor $n-1$ instead of $n$. This is included in the **cov()** function by **numpy** and **pandas**. \nOur own code here is not very elegant and asks for obvious improvements. It is tailored to this specific $2\\times 2$ covariance matrix.\n\n\n```python\n# extract the relevant columns from the centered design matrix of dim n x 2\nx = X_centered[:,0]\ny = X_centered[:,1]\nCov = np.zeros((2,2))\nCov[0,1] = np.sum(x.T@y)/(n-1.0)\nCov[0,0] = np.sum(x.T@x)/(n-1.0)\nCov[1,1] = np.sum(y.T@y)/(n-1.0)\nCov[1,0]= Cov[0,1]\nprint(\"Centered covariance using own code\")\nprint(Cov)\nplt.plot(x, y, 'x')\nplt.axis('equal')\nplt.show()\n```\n\n## Exploring\n\nDepending on the number of points $n$, we will get results that are close to the covariance values defined above.\nThe plot shows how the data are clustered around a line with slope close to one. Is this expected? Try to change the covariance and the mean values. For example, try to make the variance of the first element much larger than that of the second diagonal element. Try also to shrink the covariance (the non-diagonal elements) and see how the data points are distributed.\n\n## Diagonalize the sample covariance matrix to obtain the principal components\n\nNow we are ready to solve for the principal components! To do so we\ndiagonalize the sample covariance matrix $\\Sigma$. We can use the\nfunction **np.linalg.eig** to do so. It will return the eigenvalues and\neigenvectors of $\\Sigma$. Once we have these we can perform the \nfollowing tasks:\n\n* We compute the percentage of the total variance captured by the first principal component\n\n* We plot the mean centered data and lines along the first and second principal components\n\n* Then we project the mean centered data onto the first and second principal components, and plot the projected data. \n\n* Finally, we approximate the data as\n\n$$\nx_i \\approx \\tilde{x}_i = \\mu_n + \\langle x_i, v_0 \\rangle v_0\n$$\n\nwhere $v_0$ is the first principal component.\n\n## Collecting all Steps\n\nCollecting all these steps we can write our own PCA function and\ncompare this with the functionality included in **Scikit-Learn**. \n\nThe code here outlines some of the elements we could include in the\nanalysis. Feel free to extend upon this in order to address the above\nquestions.\n\n\n```python\n# diagonalize and obtain eigenvalues, not necessarily sorted\nEigValues, EigVectors = np.linalg.eig(Cov)\n# sort eigenvectors and eigenvalues\n#permute = EigValues.argsort()\n#EigValues = EigValues[permute]\n#EigVectors = EigVectors[:,permute]\nprint(\"Eigenvalues of Covariance matrix\")\nfor i in range(2):\n print(EigValues[i])\nFirstEigvector = EigVectors[:,0]\nSecondEigvector = EigVectors[:,1]\nprint(\"First eigenvector\")\nprint(FirstEigvector)\nprint(\"Second eigenvector\")\nprint(SecondEigvector)\n#thereafter we do a PCA with Scikit-learn\nfrom sklearn.decomposition import PCA\npca = PCA(n_components = 2)\nX2Dsl = pca.fit_transform(X)\nprint(\"Eigenvector of largest eigenvalue\")\nprint(pca.components_.T[:, 0])\n```\n\n Eigenvalues of Covariance matrix\n 9.876618994986675\n 0.0489340085461999\n First eigenvector\n [0.99999746 0.00225436]\n Second eigenvector\n [-0.00225436 0.99999746]\n Eigenvector of largest eigenvalue\n [-0.99999746 -0.00225436]\n\n\nThis code does not contain all the above elements, but it shows how we can use **Scikit-Learn** to extract the eigenvector which corresponds to the largest eigenvalue. Try to address the questions we pose before the above code. Try also to change the values of the covariance matrix by making one of the diagonal elements much larger than the other. What do you observe then?\n\n## Classical PCA Theorem\n\nWe assume now that we have a design matrix $\\boldsymbol{X}$ which has been\ncentered as discussed above. For the sake of simplicity we skip the\noverline symbol. The matrix is defined in terms of the various column\nvectors $[\\boldsymbol{x}_0,\\boldsymbol{x}_1,\\dots, \\boldsymbol{x}_{p-1}]$ each with dimension\n$\\boldsymbol{x}\\in {\\mathbb{R}}^{n}$.\n\nThe PCA theorem states that minimizing the above reconstruction error\ncorresponds to setting $\\boldsymbol{W}=\\boldsymbol{S}$, the orthogonal matrix which\ndiagonalizes the empirical covariance(correlation) matrix. The optimal\nlow-dimensional encoding of the data is then given by a set of vectors\n$\\boldsymbol{z}_i$ with at most $l$ vectors, with $l << p$, defined by the\northogonal projection of the data onto the columns spanned by the\neigenvectors of the covariance(correlations matrix).\n\n## The PCA Theorem\n\nTo show the PCA theorem let us start with the assumption that there is one vector $\\boldsymbol{s}_0$ which corresponds to a solution which minimized the reconstruction error $J$. This is an orthogonal vector. It means that we now approximate the reconstruction error in terms of $\\boldsymbol{w}_0$ and $\\boldsymbol{z}_0$ as\n\nWe are almost there, we have obtained a relation between minimizing\nthe reconstruction error and the variance and the covariance\nmatrix. Minimizing the error is equivalent to maximizing the variance\nof the projected data.\n\nWe could trivially maximize the variance of the projection (and\nthereby minimize the error in the reconstruction function) by letting\nthe norm-2 of $\\boldsymbol{w}_0$ go to infinity. However, this norm since we\nwant the matrix $\\boldsymbol{W}$ to be an orthogonal matrix, is constrained by\n$\\vert\\vert \\boldsymbol{w}_0 \\vert\\vert_2^2=1$. Imposing this condition via a\nLagrange multiplier we can then in turn maximize\n\n$$\nJ(\\boldsymbol{w}_0)= \\boldsymbol{w}_0^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0+\\lambda_0(1-\\boldsymbol{w}_0^T\\boldsymbol{w}_0).\n$$\n\nTaking the derivative with respect to $\\boldsymbol{w}_0$ we obtain\n\n$$\n\\frac{\\partial J(\\boldsymbol{w}_0)}{\\partial \\boldsymbol{w}_0}= 2\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0-2\\lambda_0\\boldsymbol{w}_0=0,\n$$\n\nmeaning that\n\n$$\n\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0=\\lambda_0\\boldsymbol{w}_0.\n$$\n\n**The direction that maximizes the variance (or minimizes the construction error) is an eigenvector of the covariance matrix**! If we left multiply with $\\boldsymbol{w}_0^T$ we have the variance of the projected data is\n\n$$\n\\boldsymbol{w}_0^T\\boldsymbol{C}[\\boldsymbol{x}]\\boldsymbol{w}_0=\\lambda_0.\n$$\n\nIf we want to maximize the variance (minimize the construction error)\nwe simply pick the eigenvector of the covariance matrix with the\nlargest eigenvalue. This establishes the link between the minimization\nof the reconstruction function $J$ in terms of an orthogonal matrix\nand the maximization of the variance and thereby the covariance of our\nobservations encoded in the design/feature matrix $\\boldsymbol{X}$.\n\nThe proof\nfor the other eigenvectors $\\boldsymbol{w}_1,\\boldsymbol{w}_2,\\dots$ can be\nestablished by applying the above arguments and using the fact that\nour basis of eigenvectors is orthogonal, see [Murphy chapter\n12.2](https://mitpress.mit.edu/books/machine-learning-1). The\ndiscussion in chapter 12.2 of Murphy's text has also a nice link with\nthe Singular Value Decomposition theorem. For categorical data, see\nchapter 12.4 and discussion therein.\n\nFor more details, see for example [Vidal, Ma and Sastry, chapter 2](https://www.springer.com/gp/book/9780387878102).\n\n## Geometric Interpretation and link with Singular Value Decomposition\n\nFor a detailed demonstration of the geometric interpretation, see [Vidal, Ma and Sastry, section 2.1.2](https://www.springer.com/gp/book/9780387878102).\n\nPrincipal Component Analysis (PCA) is by far the most popular dimensionality reduction algorithm.\nFirst it identifies the hyperplane that lies closest to the data, and then it projects the data onto it.\n\nThe following Python code uses NumPy’s **svd()** function to obtain all the principal components of the\ntraining set, then extracts the first two principal components. First we center the data using either **pandas** or our own code\n\n\n```python\nimport numpy as np\nimport pandas as pd\nfrom IPython.display import display\nnp.random.seed(100)\n# setting up a 10 x 5 vanilla matrix \nrows = 10\ncols = 5\nX = np.random.randn(rows,cols)\ndf = pd.DataFrame(X)\n# Pandas does the centering for us\ndf = df -df.mean()\ndisplay(df)\n\n# we center it ourselves\nX_centered = X - X.mean(axis=0)\n# Then check the difference between pandas and our own set up\nprint(X_centered-df)\n#Now we do an SVD\nU, s, V = np.linalg.svd(X_centered)\nc1 = V.T[:, 0]\nc2 = V.T[:, 1]\nW2 = V.T[:, :2]\nX2D = X_centered.dot(W2)\nprint(X2D)\n```\n\n\n\n\n
\n \n \n 0 \n 1 \n 2 \n 3 \n 4 \n \n \n \n \n 0 \n -1.574465 \n 0.259153 \n 1.197370 \n 0.147400 \n 0.649382 \n \n \n 1 \n 0.689519 \n 0.137652 \n -1.025709 \n 0.210340 \n -0.076938 \n \n \n 2 \n -0.282727 \n 0.351636 \n -0.539261 \n 1.216683 \n 0.340782 \n \n \n 3 \n 0.070889 \n -0.614808 \n 1.074067 \n -0.038300 \n -1.450257 \n \n \n 4 \n 1.794282 \n 1.458078 \n -0.207545 \n -0.442600 \n -0.147420 \n \n \n 5 \n 1.112383 \n 0.647473 \n 1.405890 \n 0.073598 \n -0.276263 \n \n \n 6 \n 0.397700 \n -1.526744 \n -0.712018 \n 1.216290 \n 0.418506 \n \n \n 7 \n -0.280647 \n 1.106095 \n -1.646283 \n -0.956563 \n -1.564374 \n \n \n 8 \n -0.369139 \n -0.751699 \n 0.051649 \n -0.213103 \n 0.967809 \n \n \n 9 \n -1.557795 \n -1.066837 \n 0.401842 \n -1.213743 \n 1.138775 \n \n \n
\n
\n
\n
\n
Natural Language Processing From Scratch \n
Text Representation \n
Bruno Gonçalveswww.data4sci.com
\n
\n \n
\n", "meta": {"hexsha": "b154e73c16bd590dc044e723c01bea98b968f208", "size": 247301, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "1. Text Representation.ipynb", "max_stars_repo_name": "sajag1986/NLP", "max_stars_repo_head_hexsha": "8c3b24b7cfb0371a17c86c11dece1a06155ce164", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "1. Text Representation.ipynb", "max_issues_repo_name": "sajag1986/NLP", "max_issues_repo_head_hexsha": "8c3b24b7cfb0371a17c86c11dece1a06155ce164", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "1. Text Representation.ipynb", "max_forks_repo_name": "sajag1986/NLP", "max_forks_repo_head_hexsha": "8c3b24b7cfb0371a17c86c11dece1a06155ce164", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 128.268153527, "max_line_length": 197868, "alphanum_fraction": 0.8747154278, "converted": true, "num_tokens": 7837, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014736319616964, "lm_q2_score": 0.3073580232098525, "lm_q1q2_score": 0.13220924324090516}}
{"text": "# Homework 1\n(c) 2017 Justin Bois. This work is licensed under a [Creative Commons Attribution License CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/). All code contained herein is licensed under an [MIT license](https://opensource.org/licenses/MIT).\n\n\n```python\nimport numpy as np\nimport pandas as pd\n\nimport bokeh.io\nimport bokeh.plotting\n\nfrom bokeh.models import Legend\nfrom bokeh.plotting import figure, show, output_file\n\nbokeh.io.output_notebook()\n```\n\n\n\n\n
\n
Loading BokehJS ... \n
\n\n
\n \n \n time to catastrophe with labeled tubulin (s) \n time to catastrophe with unlabeled tubulin (s) \n \n \n \n \n 0 \n 470 \n 355.0 \n \n \n 1 \n 1415 \n 425.0 \n \n \n 2 \n 130 \n 540.0 \n \n \n 3 \n 280 \n 265.0 \n \n \n 4 \n 550 \n 1815.0 \n \n \n 5 \n 65 \n 160.0 \n \n \n 6 \n 330 \n 370.0 \n \n \n 7 \n 325 \n 460.0 \n \n \n 8 \n 340 \n 190.0 \n \n \n 9 \n 95 \n 130.0 \n \n \n 10 \n 55 \n 460.0 \n \n \n 11 \n 360 \n 140.0 \n \n \n 12 \n 220 \n 295.0 \n \n \n 13 \n 225 \n 445.0 \n \n \n 14 \n 320 \n 210.0 \n \n \n 15 \n 60 \n 360.0 \n \n \n 16 \n 210 \n 575.0 \n \n \n 17 \n 155 \n 320.0 \n \n \n 18 \n 875 \n 180.0 \n \n \n 19 \n 1000 \n 180.0 \n \n \n 20 \n 475 \n 615.0 \n \n \n 21 \n 295 \n 145.0 \n \n \n 22 \n 245 \n 870.0 \n \n \n 23 \n 415 \n 420.0 \n \n \n 24 \n 305 \n 460.0 \n \n \n 25 \n 320 \n 265.0 \n \n \n 26 \n 370 \n 150.0 \n \n \n 27 \n 505 \n 770.0 \n \n \n 28 \n 1180 \n 75.0 \n \n \n 29 \n 440 \n 40.0 \n \n \n ... \n ... \n ... \n \n \n 181 \n 350 \n NaN \n \n \n 182 \n 155 \n NaN \n \n \n 183 \n 1095 \n NaN \n \n \n 184 \n 465 \n NaN \n \n \n 185 \n 215 \n NaN \n \n \n 186 \n 365 \n NaN \n \n \n 187 \n 605 \n NaN \n \n \n 188 \n 520 \n NaN \n \n \n 189 \n 280 \n NaN \n \n \n 190 \n 610 \n NaN \n \n \n 191 \n 765 \n NaN \n \n \n 192 \n 290 \n NaN \n \n \n 193 \n 240 \n NaN \n \n \n 194 \n 180 \n NaN \n \n \n 195 \n 225 \n NaN \n \n \n 196 \n 1030 \n NaN \n \n \n 197 \n 155 \n NaN \n \n \n 198 \n 215 \n NaN \n \n \n 199 \n 705 \n NaN \n \n \n 200 \n 285 \n NaN \n \n \n 201 \n 135 \n NaN \n \n \n 202 \n 465 \n NaN \n \n \n 203 \n 80 \n NaN \n \n \n 204 \n 370 \n NaN \n \n \n 205 \n 480 \n NaN \n \n \n 206 \n 195 \n NaN \n \n \n 207 \n 705 \n NaN \n \n \n 208 \n 300 \n NaN \n \n \n 209 \n 605 \n NaN \n \n \n 210 \n 600 \n NaN \n \n \n
\n
211 rows × 2 columns
\n
\n\n
\n \n \n time to catastrophe with labeled tubulin (s) \n time to catastrophe with unlabeled tubulin (s) \n \n \n \n \n 0 \n 470 \n 355.0 \n \n \n 1 \n 1415 \n 425.0 \n \n \n 2 \n 130 \n 540.0 \n \n \n 3 \n 280 \n 265.0 \n \n \n 4 \n 550 \n 1815.0 \n \n \n
\n
\n\n
\n \n \n tc_lab \n tc_unlab \n \n \n \n \n 0 \n 470 \n 355.0 \n \n \n 1 \n 1415 \n 425.0 \n \n \n 2 \n 130 \n 540.0 \n \n \n 3 \n 280 \n 265.0 \n \n \n 4 \n 550 \n 1815.0 \n \n \n
\n
\n\\\\[f(y | \\theta)\\\\]\n
\n\nHere, the model \\\\(f\\\\) accepts data values \\\\(y\\\\) as an argument, conditional on particular values of \\\\(\\theta\\\\).\n\nFrequentist inference typically involves deriving **estimators** for the unknown parameters. Estimators are formulae that return estimates for particular estimands, as a function of data. They are selected based on some chosen optimality criterion, such as *unbiasedness*, *variance minimization*, or *efficiency*.\n\n> For example, lets say that we have collected some data on the prevalence of autism spectrum disorder (ASD) in some defined population. Our sample includes \\\\(n\\\\) sampled children, \\\\(y\\\\) of them having been diagnosed with autism. A frequentist estimator of the prevalence \\\\(p\\\\) is:\n\n> \n> $$\\hat{p} = \\frac{y}{n}$$\n>
\n\n> Why this particular function? Because it can be shown to be unbiased and minimum-variance.\n\nIt is important to note that, in a frequentist world, new estimators need to be derived for every estimand that is introduced.\n\n### The Bayesian World View\n\n\n\n- Data are considered **fixed**. They used to be random, but once they were written into your lab notebook/spreadsheet/IPython notebook they do not change.\n- Model parameters themselves may not be random, but Bayesians use probability distribtutions to describe their uncertainty in parameter values, and are therefore treated as **random**. In some cases, it is useful to consider parameters as having been sampled from probability distributions.\n\nThis implies the following form:\n\n\n\\\\[p(\\theta | y)\\\\]\n
\n\nThis formulation used to be referred to as ***inverse probability***, because it infers from observations to parameters, or from effects to causes.\n\nBayesians do not seek new estimators for every estimation problem they encounter. There is only one estimator for Bayesian inference: **Bayes' Formula**.\n\n## Bayes' Formula\n\nNow that we have some probability under our belt, we turn to Bayes' formula. While frequentist statistics uses different estimators for different problems, Bayes formula is the **only estimator** that Bayesians need to obtain estimates of unknown quantities that we care about. \n\n\n\nThe equation expresses how our belief about the value of \\\\(\\theta\\\\), as expressed by the **prior distribution** \\\\(P(\\theta)\\\\) is reallocated following the observation of the data \\\\(y\\\\).\n\nThe innocuous denominator \\\\(P(y)\\\\) usuallt cannot be computed directly, and is actually the expression in the numerator, integrated over all \\\\(\\theta\\\\):\n\n \n\\\\[Pr(\\theta|y) = \\frac{Pr(y|\\theta)Pr(\\theta)}{\\int Pr(y|\\theta)Pr(\\theta) d\\theta}\\\\]\n
\n\nThe intractability of this integral is one of the factors that has contributed to the under-utilization of Bayesian methods by statisticians.\n\n### Priors\n\nOnce considered a controversial aspect of Bayesian analysis, the prior distribution characterizes what is known about an unknown quantity before observing the data from the present study. Thus, it represents the information state of that parameter. It can be used to reflect the information obtained in previous studies, to constrain the parameter to plausible values, or to represent the population of possible parameter values, of which the current study's parameter value can be considered a sample.\n\n### Likelihood functions\n\nThe likelihood represents the information in the observed data, and is used to update prior distributions to posterior distributions. This updating of belief is justified becuase of the **likelihood principle**, which states:\n\n> Following observation of \\\\(y\\\\), the likelihood \\\\(L(\\theta|y)\\\\) contains all experimental information from \\\\(y\\\\) about the unknown \\\\(\\theta\\\\).\n\nBayesian analysis satisfies the likelihood principle because the posterior distribution's dependence on the data is **only through the likelihood**. In comparison, most frequentist inference procedures violate the likelihood principle, because inference will depend on the design of the trial or experiment.\n\nRemember from the density estimation section that the likelihood is closely related to the probability density (or mass) function. The difference is that the likelihood varies the parameter while holding the observations constant, rather than *vice versa*.\n\n## Bayesian Inference, in 3 Easy Steps\n\n\n\nGelman et al. (2013) describe the process of conducting Bayesian statistical analysis in 3 steps.\n\n### Step 1: Specify a probability model\n\nAs was noted above, Bayesian statistics involves using probability models to solve problems. So, the first task is to *completely specify* the model in terms of probability distributions. This includes everything: unknown parameters, data, covariates, missing data, predictions. All must be assigned some probability density.\n\nThis step involves making choices.\n\n- what is the form of the sampling distribution of the data?\n- what form best describes our uncertainty in the unknown parameters?\n\n### Discrete Random Variables\n\n$$X = \\{0,1\\}$$\n\n$$Y = \\{\\ldots,-2,-1,0,1,2,\\ldots\\}$$\n\n**Probability Mass Function**: \n\nFor discrete $X$,\n\n$$Pr(X=x) = f(x|\\theta)$$\n\n\n\n***e.g. Poisson distribution***\n\nThe Poisson distribution models unbounded counts:\n\n \n$$Pr(X=x)=\\frac{e^{-\\lambda}\\lambda^x}{x!}$$\n
\n\n* $X=\\{0,1,2,\\ldots\\}$\n* $\\lambda > 0$\n\n$$E(X) = \\text{Var}(X) = \\lambda$$\n\n\n```python\nfrom pymc3 import Poisson\n\nx = Poisson.dist(mu=1)\nsamples = x.random(size=10000)\n```\n\n\n```python\nsamples.mean()\n```\n\n\n\n\n 1.0115\n\n\n\n\n```python\nplt.hist(samples, bins=len(set(samples)));\n```\n\n### Continuous Random Variables\n\n$$X \\in [0,1]$$\n\n$$Y \\in (-\\infty, \\infty)$$\n\n**Probability Density Function**: \n\nFor continuous $X$,\n\n$$Pr(x \\le X \\le x + dx) = f(x|\\theta)dx \\, \\text{ as } \\, dx \\rightarrow 0$$\n\n\n\n***e.g. normal distribution***\n\n \n$$f(x) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}}\\exp\\left[-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right]$$\n
\n\n* $X \\in \\mathbf{R}$\n* $\\mu \\in \\mathbf{R}$\n* $\\sigma>0$\n\n$$\\begin{align}E(X) &= \\mu \\cr\n\\text{Var}(X) &= \\sigma^2 \\end{align}$$\n\n\n```python\nfrom pymc3 import Normal\n\ny = Normal.dist(mu=-2, sd=4)\nsamples = y.random(size=10000)\n```\n\n\n```python\nsamples.mean()\n```\n\n\n\n\n -2.027323774069744\n\n\n\n\n```python\nsamples.std()\n```\n\n\n\n\n 3.969166857847105\n\n\n\n\n```python\nplt.hist(samples);\n```\n\n### Step 2: Calculate a posterior distribution\n\nThe mathematical form \\\\(p(\\theta | y)\\\\) that we associated with the Bayesian approach is referred to as a **posterior distribution**.\n\n> posterior /pos·ter·i·or/ (pos-tēr´e-er) later in time; subsequent.\n\nWhy posterior? Because it tells us what we know about the unknown \\\\(\\theta\\\\) *after* having observed \\\\(y\\\\).\n\nThis posterior distribution is formulated as a function of the probability model that was specified in Step 1. Usually, we can write it down but we cannot calculate it analytically. In fact, the difficulty inherent in calculating the posterior distribution for most models of interest is perhaps the major contributing factor for the lack of widespread adoption of Bayesian methods for data analysis. Various strategies for doing so comprise this tutorial.\n\n**But**, once the posterior distribution is calculated, you get a lot for free:\n\n- point estimates\n- credible intervals\n- quantiles\n- predictions\n\n### Step 3: Check your model\n\nThough frequently ignored in practice, it is critical that the model and its outputs be assessed before using the outputs for inference. Models are specified based on assumptions that are largely unverifiable, so the least we can do is examine the output in detail, relative to the specified model and the data that were used to fit the model.\n\nSpecifically, we must ask:\n\n- does the model fit data?\n- are the conclusions reasonable?\n- are the outputs sensitive to changes in model structure?\n\n\n\n## Estimation for one group\n\nBefore we compare two groups using Bayesian analysis, let's start with an even simpler scenario: statistical inference for one group.\n\nFor this we will use Gelman et al.'s (2007) radon dataset. In this dataset the amount of the radioactive gas radon has been measured among different households in all counties of several states. Radon gas is known to be the highest cause of lung cancer in non-smokers. It is believed to be more strongly present in households containing a basement and to differ in amount present among types of soil.\n\n> the US EPA has set an action level of 4 pCi/L. At or above this level of radon, the EPA recommends you take corrective measures to reduce your exposure to radon gas.\n\n\n\nLet's import the dataset:\n\n\n```python\nradon = pd.read_csv('../data/radon.csv', index_col=0)\nradon.head()\n```\n\n\n\n\n\n\n
\n \n \n idnum \n state \n state2 \n stfips \n zip \n region \n typebldg \n floor \n room \n basement \n ... \n pcterr \n adjwt \n dupflag \n zipflag \n cntyfips \n county \n fips \n Uppm \n county_code \n log_radon \n \n \n \n \n 0 \n 5081.0 \n MN \n MN \n 27.0 \n 55735 \n 5.0 \n 1.0 \n 1.0 \n 3.0 \n N \n ... \n 9.7 \n 1146.499190 \n 1.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 0.832909 \n \n \n 1 \n 5082.0 \n MN \n MN \n 27.0 \n 55748 \n 5.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 14.5 \n 471.366223 \n 0.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 0.832909 \n \n \n 2 \n 5083.0 \n MN \n MN \n 27.0 \n 55748 \n 5.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 9.6 \n 433.316718 \n 0.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 1.098612 \n \n \n 3 \n 5084.0 \n MN \n MN \n 27.0 \n 56469 \n 5.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 24.3 \n 461.623670 \n 0.0 \n 0.0 \n 1.0 \n AITKIN \n 27001.0 \n 0.502054 \n 0 \n 0.095310 \n \n \n 4 \n 5085.0 \n MN \n MN \n 27.0 \n 55011 \n 3.0 \n 1.0 \n 0.0 \n 4.0 \n Y \n ... \n 13.8 \n 433.316718 \n 0.0 \n 0.0 \n 3.0 \n ANOKA \n 27003.0 \n 0.428565 \n 1 \n 1.163151 \n \n \n
\n
5 rows × 29 columns
\n
\n\n
\n \n \n Jan \n Feb \n Mar \n Apr \n May \n Jun \n Jul \n Aug \n Sep \n Oct \n Nov \n Dec \n \n \n Year \n \n \n \n \n 1871 \n 2.76 \n 4.58 \n 5.01 \n 4.13 \n 3.30 \n 2.98 \n 1.58 \n 2.36 \n 0.95 \n 1.31 \n 2.13 \n 1.65 \n \n \n 1872 \n 2.32 \n 2.11 \n 3.14 \n 5.91 \n 3.09 \n 5.17 \n 6.10 \n 1.65 \n 4.50 \n 1.58 \n 2.25 \n 2.38 \n \n \n 1873 \n 2.96 \n 7.14 \n 4.11 \n 3.59 \n 6.31 \n 4.20 \n 4.63 \n 2.36 \n 1.81 \n 4.28 \n 4.36 \n 5.94 \n \n \n 1874 \n 5.22 \n 9.23 \n 5.36 \n 11.84 \n 1.49 \n 2.87 \n 2.65 \n 3.52 \n 3.12 \n 2.63 \n 6.12 \n 4.19 \n \n \n 1875 \n 6.15 \n 3.06 \n 8.14 \n 4.22 \n 1.73 \n 5.63 \n 8.12 \n 1.60 \n 3.79 \n 1.25 \n 5.46 \n 4.30 \n \n \n
\n
\n\n
\n \n \n birth \n exit \n hospstay \n lowph \n pltct \n race \n bwt \n gest \n inout \n twn \n ... \n vent \n pneumo \n pda \n cld \n pvh \n ivh \n ipe \n year \n sex \n dead \n \n \n \n \n 5 \n 81.593002 \n 81.598999 \n 2.0 \n 6.969997 \n 54.0 \n black \n 925.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 1.0 \n 1.0 \n 0.0 \n 0.0 \n definite \n definite \n NaN \n 81.594055 \n female \n 1 \n \n \n 6 \n 81.601997 \n 81.771004 \n 62.0 \n 7.189999 \n NaN \n white \n 940.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 1.0 \n 0.0 \n 0.0 \n 0.0 \n absent \n absent \n absent \n 81.602295 \n female \n 0 \n \n \n 13 \n 81.683998 \n 81.853996 \n 62.0 \n 7.179996 \n 182.0 \n black \n 1110.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 0.0 \n 1.0 \n 0.0 \n 1.0 \n absent \n absent \n absent \n 81.684448 \n male \n 0 \n \n \n 14 \n 81.689003 \n 81.877998 \n 69.0 \n 7.419998 \n 361.0 \n white \n 1180.0 \n 28.0 \n born at Duke \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n absent \n absent \n absent \n 81.689880 \n male \n 0 \n \n \n 16 \n 81.696999 \n 81.952004 \n 93.0 \n 7.239998 \n 255.0 \n black \n 770.0 \n 26.0 \n born at Duke \n 0.0 \n ... \n 1.0 \n 0.0 \n 0.0 \n 1.0 \n absent \n absent \n absent \n 81.698120 \n male \n 0 \n \n \n
\n
5 rows × 26 columns
\n
\n\n
\n \n \n pneumo \n 0.0 \n 1.0 \n \n \n ivh \n \n \n \n \n absent \n 359 \n 73 \n \n \n definite \n 45 \n 30 \n \n \n possible \n 6 \n 4 \n \n \n
\n
\n\n## Live Lecture - Deriving Bayes' Theorem, Calculating Bayesian Confidence\n\nNotice that $P(A|B)$ appears in the above laws - in Bayesian terms, this is the belief in $A$ updated for the evidence $B$. So all we need to do is solve for this term to derive Bayes' theorem. Let's do it together!\n\n\n```\n# Activity 2 - Use SciPy to calculate Bayesian confidence intervals\n# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bayes_mvs.html#scipy.stats.bayes_mvs\n```\n\n\n```\nfrom scipy import stats\nimport numpy as np\n\nnp.random.seed(seed=42)\n\ncoinflips = np.random.binomial(n=1, p=.5, size=100)\nprint(coinflips)\n```\n\n [0 1 1 1 0 0 0 1 1 1 0 1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1 1 0 1 0 0 1 1 1 0\n 0 1 0 0 0 0 1 0 1 0 1 1 0 1 1 1 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 0 1 1 0 0 1\n 1 1 1 0 0 0 1 1 0 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 0 0]\n\n\n\n```\ndef confidence_interval(data, confidence=.95):\n n = len(data)\n mean = sum(data)/n\n data = np.array(data)\n stderr = stats.sem(data)\n interval = stderr * stats.t.ppf((1 + confidence) / 2.0, n-1)\n return (mean , mean-interval, mean+interval)\n```\n\n\n```\nconfidence_interval(coinflips, confidence=.95)\n```\n\n\n\n\n (0.47, 0.3704689875017368, 0.5695310124982632)\n\n\n\n\n```\nmean_CI, _, _ = stats.bayes_mvs(coinflips, alpha=.95)\n \nmean_CI\n```\n\n\n\n\n Mean(statistic=0.47, minmax=(0.37046898750173674, 0.5695310124982632))\n\n\n\n\n```\n??stats.bayes_mvs\n```\n\n\n```\ncoinflips_mean_dist, _, _ = stats.mvsdist(coinflips)\ncoinflips_mean_dist\n```\n\n\n\n\n \n\n\n\n\n```\ncoinflips_mean_dist.rvs(1000)\n```\n\n## Assignment - Code it up!\n\nMost of the above was pure math - now write Python code to reproduce the results! This is purposefully open ended - you'll have to think about how you should represent probabilities and events. You can and should look things up, and as a stretch goal - refactor your code into helpful reusable functions!\n\nSpecific goals/targets:\n\n1. Write a function `def prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk)` that reproduces the example from lecture, and use it to calculate and visualize a range of situations\n2. Explore `scipy.stats.bayes_mvs` - read its documentation, and experiment with it on data you've tested in other ways earlier this week\n3. Create a visualization comparing the results of a Bayesian approach to a traditional/frequentist approach\n4. In your own words, summarize the difference between Bayesian and Frequentist statistics\n\nIf you're unsure where to start, check out [this blog post of Bayes theorem with Python](https://dataconomy.com/2015/02/introduction-to-bayes-theorem-with-python/) - you could and should create something similar!\n\nStretch goals:\n\n- Apply a Bayesian technique to a problem you previously worked (in an assignment or project work) on from a frequentist (standard) perspective\n- Check out [PyMC3](https://docs.pymc.io/) (note this goes beyond hypothesis tests into modeling) - read the guides and work through some examples\n- Take PyMC3 further - see if you can build something with it!\n\n\n```\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n```\n\n\n```\n# TODO - code!\n\ndef prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk):\n # reproduces the example from lecture, and use it to calculate and visualize a range of situations\n return prob_positive_drunk * prob_drunk_prior / prob_positive\n```\n\n\n```\ni = 1\ndf = pd.DataFrame(columns=['index','post_prob'])\nindex = []\npost_list = []\n```\n\n\n```\ndef prob_drunk_positive_recursive(prob_drunk_prior, false_positive, true_positive, n):\n# global result\n post_prob = true_positive * prob_drunk_prior / (false_positive + prob_drunk_prior)\n \n global i\n index.append(int(i))\n post_list.append(post_prob)\n# print(i, post_prob)\n i += 1\n \n while i < n:\n prob_drunk_positive_recursive(post_prob, false_positive, true_positive, n)\n# return result\n\n```\n\n\n```\nprob_drunk_positive_recursive(.001, .08, 1, 11)\n```\n\n\n```\nindex, post_list\n```\n\n\n\n\n ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10],\n [0.012345679012345678,\n 0.1336898395721925,\n 0.6256256256256255,\n 0.8866254326732111,\n 0.9172378490200085,\n 0.9197784158727866,\n 0.9199822693409904,\n 0.9199985815221288,\n 0.9199998865216094,\n 0.9199999909217278])\n\n\n\n\n```\ndf['index'] = np.array(index)\ndf['post_prob'] = np.array(post_list)\n```\n\n\n```\ndf.head(10)\n```\n\n\n\n\n\n\n
\n \n \n index \n post_prob \n \n \n \n \n 0 \n 1 \n 0.012346 \n \n \n 1 \n 2 \n 0.133690 \n \n \n 2 \n 3 \n 0.625626 \n \n \n 3 \n 4 \n 0.886625 \n \n \n 4 \n 5 \n 0.917238 \n \n \n 5 \n 6 \n 0.919778 \n \n \n 6 \n 7 \n 0.919982 \n \n \n 7 \n 8 \n 0.919999 \n \n \n 8 \n 9 \n 0.920000 \n \n \n 9 \n 10 \n 0.920000 \n \n \n
\n
Introducción al estudio del Método de los Elementos Finitos Una aproximación al análisis estático lineal Sesion 01 - Introducción \n \n Text provided under a Creative Commons Attribution license, CC-BY. All code is made available under the FSF-approved MIT license.(c) Carlos Alberto Alvarez Henao \n
\n\n*** \n\n***Docente:*** Carlos Alberto Álvarez Henao, I.C. D.Sc.\n\n***e-mail:*** carlosalvarezh@gmail.com\n\n***skype:*** carlos.alberto.alvarez.henao\n\n***Herramienta:*** [Jupyter Notebook](http://jupyter.org/)\n\n***Kernel:*** Python 3.8\n\n***MEDELLÍN - COLOMBIA***\n\n***2021/02***\n\n***\n\nTabla de Contenidos \n\n\n\n \n
\n\n## Introducción\n\n\n \n
\n\n### Mecánica\n\nLa [Mecánica](https://en.wikipedia.org/wiki/Mechanics) es el área de la física que estudia el movimiento y reposo de los cuerpos, y su evolución con el tiempo, más específicamente la relación entre fuerza, materia y movimiento. Las fuerzas aplicadas a los objetos dan como resultados desplazamientos o cambios de la posición de un objeto en relación con su entorno.\n\nLos problemas a ser tratados en este curso se enmarcan dentro de la [Mecánica computacional](https://en.wikipedia.org/wiki/Computational_mechanics), análisis estático lineal, como se observa en el siguiente esquema:\n\n\\begin{equation*}\n\\text{Mecánica} \\left \\{\n\\begin{aligned}\n&\\text{Teórica} \\\\\n&\\text{Computacional} \\left \\{\n\\begin{aligned}\n&\\text{Nano/micro} \\\\\n&\\text{Continuo} \\left \\{\n\\begin{aligned}\n&\\text{Fluidos} \\\\\n&\\text{Sólidos} \\left \\{\n\\begin{aligned}\n&\\text{Estática} \\left \\{\n\\begin{aligned}\n&\\text{Lineal} \\\\\n&\\text{No Lineal}\n\\end{aligned}\n\\right.\n\\\\\n&\\text{Dinámica}\n\\end{aligned}\n\\right.\n\\\\\n&\\text{Multifísica}\n\\end{aligned}\n\\right.\n\\\\\n&\\text{Sistema}\n\\end{aligned}\n\\right.\n\\\\\n&\\text{Aplicada}\n\\end{aligned}\n\\right.\n\\end{equation*}\n\n#### Modelación y Simulación Computacional\n\n\n \n
\n\nLa Ciencia Computacional e Ingeniería, es una disciplina que concierne al uso de métodos y dispositivos computacionales para simular eventos físicos y sistemas en ingeniería.\n\n#### Discretización\n\n\n \n
\n\nEl proceso de [discretización](https://en.wikipedia.org/wiki/Discretization) consiste en transformar un modelo continuo en un finito número de componentes discretos que pueden ser procesados por una máquina. El [modelo Computacional](https://en.wikipedia.org/wiki/Computational_model) es la versión discretizada de un modelo matemático que se ha desarrollado para ser implementado en una máquina de cómputo. Esta discplina incluye la [modelación matemática](https://en.wikipedia.org/wiki/Mathematical_model), que es un conjunto de ecuaciones algebraicas, diferenciales y/o integrales, que gobiernan un fenómeno físico de un sistema en particular. El modelo se basa en una serie de suposiciones y restricciones impuestas al fenómeno y de las leyes físicas gobernantes.\n\nAlgunos métodos empleados en la discretización espacial son:\n\n- ***[Elementos Finitos](https://en.wikipedia.org/wiki/Finite_element_method) (FEM)***\n\n\n- ***[Elementos de Contorno](https://en.wikipedia.org/wiki/Boundary_element_method) (BEM)***\n\n\n- ***[Diferencias Finitas](https://en.wikipedia.org/wiki/Finite_difference_method) (FDM)***\n\n\n- ***[Spectral](https://en.wikipedia.org/wiki/Spectral_method)***\n\n\n- ***[Libres de Malla](https://en.wikipedia.org/wiki/Meshfree_methods) (Mesfree)***\n\nCada uno de ellos presenta ventajas y desventajas que deberán ser aprovechadas según el tipo de problema a resolver. En este curso nos centraremos únicamente en el ***Método de los Elementos Finitos (FEM)***.\n\n#### Qué es un *Elemento Finito*?\n\nPara captar la idea de lo que es un elemento finito, veamos un ejemplo en donde se calcula el valor de $\\pi$ empleando el método propuesto originalmente por [*Arquimedes*](https://en.wikipedia.org/wiki/Approximations_of_%CF%80). Él sabía que la relación entre la circunferencia de un círculo y su diámetro era $\\pi$. Tenía la idea de que podía dibujar un polígono regular inscrito dentro del círculo para aproximarse a $\\pi$, y cuantos más lados dibujara en el polígono, mejor aproximación a $\\pi$ obtendría. En matemáticas modernas, diríamos que como el número de lados del polígono tiende a infinito, la circunferencia tiende a $2\\pi$. Sin embargo, en lugar de dibujar el polígono, Arquímedes calculó la longitud usando un argumento geométrico, como el siguiente:\n\n\n \n
\n\nDibuja un círculo de radio $1$ centrado en $A$. Inscribe un polígono de $N$ lados dentro de él. Nuestra estimación de $\\pi$ es la mitad de la circunferencia del polígono (la circunferencia de un círculo es $2\\pi r$, $r=1$, lo que da $2\\pi$). A medida que los lados del polígono se hacen cada vez más pequeños, la circunferencia se acerca cada vez más a $2\\pi$.\n\nEl diagrama muestra un segmento del polígono $ACE$. El lado del polígono $CE$ tiene una longitud $d_n$. Suponiendo que conocemos $d$ para un polígono de $N$ lados, si podemos encontrar una expresión para la longitud $CD=d_{2n}$, la longitud del borde de un polígono con $2N$ lados, solo en términos de $d_n$, entonces podemos mejorar nuestra estimación de $\\pi$. Intentemos hacer eso.\n\nBisecamos el triángulo $CAE$ para hacer que $CAD$ y $DAE$ sean los dos nuevos segmentos iguales del polígono de $2N$ lados. Usando el teorema de Pitágoras en el triángulo rectángulo $ABC$, tenemos\n\n$$AB^2+BC^2=1^2=1$$\n$$AB=\\sqrt{1+BC^2}$$\n\ndado que\n\n$$BC=\\frac{d_n}{2}$$\n\nsustituyendo,\n\n$$AB=\\sqrt{1-\\left( \\frac{d_n}{2}\\right)^2}$$\n$$BD=1-AB=1-\\sqrt{1-\\frac{d^2_n}{4}}$$\n\nUsando el teorema de Pitágoras en el triángulo rectángulo $CBD$\n\n$$CD^2=BC^2+BD^2$$\n\nreemplazando\n\n$$CD=d_{2n}=\\sqrt{2-2\\sqrt{1-\\frac{d^2_n}{4}}}$$\n\n$d_{2n}$ es la longitud de un lado del polígono con $2N$ lados.\n\nEsto significa que si conocemos la longitud de los lados de un polígono con $N$ lados, entonces podemos calcular la longitud de los lados de un polígono con $2N$ lados. ¿Qué significa esto? Comencemos con un cuadrado. La inscripción de un cuadrado en un círculo se ve así, con la longitud del lado $\\sqrt{2}$. Esto da una estimación de $\\pi$ como $2\\sqrt{2}$, que es pobre ($\\approx2.828$) pero es solo el comienzo del proceso.\n\n\n \n
\n\nPodemos calcular la longitud del lado de un octágono, a partir de la longitud del lado de un cuadrado, y la longitud del lado de un $16$-gono a partir de un octágono, etc.\n\n\n \n
\n\n\n\n```python\ndef piArchimedes(n):\n \"\"\"\n Calculate n iterations of Archimedes PI recurrence relation\n \"\"\"\n polygon_edge = 2.0\n polygon_sides = 4\n for i in range(n):\n polygon_edge = 2 - 2 * math.sqrt(1 - polygon_edge / 4)\n polygon_sides *= 2\n return polygon_sides * math.sqrt(polygon_edge) / 2\n```\n\n\n```python\nimport math\n\nprint(\"n \\t pi approx \\t Error(%)\")\nprint(\"1 \\t {0:6.8f} \\t -\".format(0, ))\n\nfor n in range(16):\n result = piArchimedes(n)\n error = abs(result - math.pi) / math.pi\n print(\"{0} \\t {1:4.8f} \\t {2:4.8f}\".format(n, result, error))\n\n```\n\n n \t pi approx \t Error(%)\n 1 \t 0.00000000 \t -\n 0 \t 2.82842712 \t 0.09968368\n 1 \t 3.06146746 \t 0.02550464\n 2 \t 3.12144515 \t 0.00641315\n 3 \t 3.13654849 \t 0.00160561\n 4 \t 3.14033116 \t 0.00040155\n 5 \t 3.14127725 \t 0.00010040\n 6 \t 3.14151380 \t 0.00002510\n 7 \t 3.14157294 \t 0.00000627\n 8 \t 3.14158773 \t 0.00000157\n 9 \t 3.14159142 \t 0.00000039\n 10 \t 3.14159235 \t 0.00000010\n 11 \t 3.14159258 \t 0.00000002\n 12 \t 3.14159263 \t 0.00000001\n 13 \t 3.14159265 \t 0.00000000\n 14 \t 3.14159265 \t 0.00000000\n 15 \t 3.14159261 \t 0.00000001\n\n\n\n\n### Qué es el FEM?\n\nEl [Método de los Elementos Finitos](https://en.wikipedia.org/wiki/Finite_element_method) (FEM, en inglés) es una técnica numérica empleada principalmente para resolver [ecuaciones diferenciales](https://en.wikipedia.org/wiki/Differential_equation), que surgen en el [modelamiento matemático](https://en.wikipedia.org/wiki/Mathematical_model) en áreas como la ingeniería, ciencias básicas, sociales, entre muchas otras.\n\n#### FEM o FEA?\n\nEl método de elementos finitos (FEM) es una técnica numérica utilizada para realizar análisis de elementos finitos (FEA) de cualquier fenómeno físico dado.\n\nEs necesario utilizar las matemáticas para comprender y cuantificar de manera integral cualquier fenómeno físico, como el comportamiento estructural o de los fluidos, el transporte térmico, la propagación de ondas y el crecimiento de células biológicas. La mayoría de estos procesos se describen mediante ecuaciones diferenciales parciales (PDE). Sin embargo, para que una computadora resuelva estas PDE, se han desarrollado técnicas numéricas durante las últimas décadas y una de las más destacadas en la actualidad es el método de elementos finitos.\n\n#### Aplicaciones del FEM\n\nEl método de elementos finitos comenzó con una promesa significativa en el modelado de varias aplicaciones mecánicas relacionadas con la ingeniería aeroespacial y civil. Las aplicaciones del método de los elementos finitos recién ahora están comenzando a alcanzar su potencial. Una de las perspectivas más interesantes es su aplicación en [problemas acoplados](https://en.wikipedia.org/wiki/Coupling_(physics)) tales como [interacción fluido-estructura](https://en.wikipedia.org/wiki/Fluid%E2%80%93structure_interaction)(FSI), problemas [termomecánicos](https://en.wikipedia.org/wiki/Thermomechanical_analysis), [termoquímicos](https://en.wikipedia.org/wiki/Thermochemical_cycle), [biomecánica](https://en.wikipedia.org/wiki/Biomechanics), [ingeniería biomédica](https://en.wikipedia.org/wiki/Biomedical_sciences), [piezoeléctrica](https://en.wikipedia.org/wiki/Piezoelectricity), y [electromagnética](https://en.wikipedia.org/wiki/Computational_electromagnetics), entre muchos otros.\n\n#### Ecuaciones Diferenciales en Derivadas Parciales\n\nEn matemáticas, una [Ecuación Diferencial en Derivadas Parciales](https://en.wikipedia.org/wiki/Partial_differential_equation) (PDE, de sus siglas en inglés) es una ecuación que impone relaciones entre las diversas derivadas parciales de una función multivariable. Existen diferentes formas de escribir una PDE, pero de las más comunes son:\n\n$$u_x=\\frac{\\partial u}{\\partial x}, \\quad u_{xx}=\\frac{\\partial^2 u}{\\partial x^2}, \\quad u_{xy}=\\frac{\\partial^2 u}{\\partial x \\partial y}=\\frac{\\partial}{\\partial y} \\left( \\frac{\\partial u}{\\partial x}\\right),$$\n\nEs importante comprender los diferentes géneros de PDE y su idoneidad para su uso con FEM. Comprender esto es particularmente importante para todos, independientemente de la motivación para usar el análisis de elementos finitos. Es fundamental recordar que FEM es una herramienta y cualquier herramienta es tan buena como su usuario.\n\nAunque, como se ha indicado, el FEM es una herramienta para resolver PDEs, en el curso no se realizará un desarrollo teórico de este tema, por lo que se deja al usuario la responsabilidad de su estudio y adecuado entendimiento. En el libro de [Kreyszig](https://soaneemrana.org/onewebmedia/ADVANCED%20ENGINEERING%20MATHEMATICS%20BY%20ERWIN%20ERESZIG1.pdf), capítulo 12, encontrará información que puede ser una buena referencia para estudio. También el notebook de [Ecuaciones Diferenciales con Python](https://relopezbriega.github.io/blog/2016/01/10/ecuaciones-diferenciales-con-python/) del profesor Raúl Lopez Briega, en español, en donde podrá realizar algunas aplicaciones empleando programación en `python`.\n\n#### Cómo trabaja el FEM?\n\nEl [principio de minimización de la energía](https://en.wikipedia.org/wiki/Principle_of_minimum_energy) forma la columna vertebral principal del método de elementos finitos. En otras palabras, cuando se aplica una condición de contorno específica a un cuerpo (como desplazamiento o fuerza), esto puede conducir a varias configuraciones, pero sin embargo, solo una configuración particular es posible o lograda de manera realista. Sólo se elige aquella configuración donde la energía total es mínima. Incluso cuando la simulación se realiza varias veces, prevalecen los mismos resultados. \n\n#### Historia del FEM\n\nDependiendo de la perspectiva histórica, se puede decir que el FEM tuvo sus orígenes en la obra de Euler, ya en el siglo XVI. Sin embargo, los primeros trabajos matemáticos sobre FEM se pueden encontrar en los trabajos de Schellback(1851) y Courant(1943).\n\nEl FEM fue desarrollado de forma independiente por ingenieros para abordar problemas de mecánica estructural relacionados con la ingeniería aeroespacial y civil. Los desarrollos comenzaron a mediados de la década de 1950 con los artículos de [Turner, Clough, Martin y Topp](http://www.ce.memphis.edu/7117/notes/presentations/papers/Turner%20et%20al%20(1956)%20Stiffness%20and%20deflection%20analysis%20of%20comlex%20strucutres.pdf)(1956), [Argyris](https://en.wikipedia.org/wiki/John_Argyris)(1957) y [Babuska y Aziz](https://www.elsevier.com/books/the-mathematical-foundations-of-the-finite-element-method-with-applications-to-partial-differential-equations/aziz/978-0-12-068650-6)(1972). Los libros de [Zienkiewicz](https://en.wikipedia.org/wiki/Olgierd_Zienkiewicz)(1971) sentaron las bases para el desarrollo futuro en FEM.\n\nUna revisión interesante de estos desarrollos históricos se puede encontrar en Oden(1991). Se puede encontrar una revisión del desarrollo de FEM durante los últimos 75 años en este artículo de blog: [75 Years of the Finite Element Method](https://www.simscale.com/blog/2015/11/75-years-of-the-finite-element-method-fem/). En el artículo de [Gupta y Meek](https://people.sc.fsu.edu/~jpeterson/history_fem.pdf)(1996) o en este documento de curso del profesor [Mohite](http://home.iitk.ac.in/~mohite/History_of_FEM.pdf), podrá encontrar más información.\n\n\n\n### Diferentes tipos del FEM\n\nComo se discutió anteriormente, la tecnología FEM tradicional ha demostrado deficiencias en los problemas de modelado relacionados con la mecánica de fluidos y la propagación de ondas. Recientemente se han realizado varias mejoras para optimizar el proceso de solución y ampliar la aplicabilidad del análisis de elementos finitos a una amplia gama de problemas. Algunos de los importantes que aún se utilizan incluyen:\n\n#### Método de elementos finitos extendido (XFEM)\n\nEl método de Bubnov-Galerkin requiere continuidad de desplazamiento entre elementos. Aunque problemas como el contacto, la fractura y el daño implican discontinuidades y saltos que no pueden manejarse directamente con el método de elementos finitos. Para superar esta deficiencia, [XFEM](https://en.wikipedia.org/wiki/Extended_finite_element_method) nació en la década de 1990. XFEM funciona mediante la expansión de las funciones de forma con las funciones de pasos de Heaviside. Se asignan grados de libertad adicionales a los nodos alrededor del punto de discontinuidad para que se puedan considerar los saltos.\n\n#### Método de elementos finitos generalizado (GFEM)\n\n[GFEM](https://www.sciencedirect.com/science/article/abs/pii/S0045782501001888) se introdujo casi al mismo tiempo que XFEM en los años 90. Combina las características de los métodos tradicionales FEM y sin malla. Las funciones de forma se definen principalmente por las coordenadas globales y luego se multiplican por partición de unidad para crear funciones de forma elementales locales. Una de las ventajas de GFEM es la prevención de remallado alrededor de singularidades.\n\n#### Método mixto de elementos finitos\n\nEl [Método mixto de elementos finitos](https://en.wikipedia.org/wiki/Mixed_finite_element_method) se aplica en varios problemas, como el contacto o la incompresibilidad, en el que las restricciones se imponen utilizando multiplicadores de Lagrange. Estos grados de libertad extra que surgen de los multiplicadores de Lagrange se resuelven de forma independiente. El sistema de ecuaciones se resuelve como un sistema acoplado de ecuaciones.\n\n#### Método de elementos finitos hp\n\n[hp-FEM](https://en.wikipedia.org/wiki/Hp-FEM) es una combinación de refinamiento automático de malla (refinamiento h) y un aumento en el orden de polinomio (refinamiento p). Esto no es lo mismo que hacer refinamientos h y p por separado. Cuando se utiliza el refinamiento hp automático y un elemento se divide en elementos más pequeños (refinamiento h), cada elemento también puede tener diferentes órdenes polinomiales.\n\n#### Método de elementos finitos de Galerkin discontinuo (DG-FEM)\n\n[DG-FEM](https://en.wikipedia.org/wiki/Discontinuous_Galerkin_method) ha mostrado una promesa significativa para utilizar la idea de elementos finitos para resolver ecuaciones hiperbólicas, donde los métodos tradicionales de elementos finitos han sido débiles. Además, también ha mostrado mejoras en la flexión y problemas incompresibles que se observan típicamente en la mayoría de los procesos de materiales. Aquí, se agregan restricciones adicionales a la forma débil que incluye un parámetro de penalización (para evitar la interpenetración) y términos para otro equilibrio de tensiones entre los elementos.\n\n\n\n### El proceso de análisis *FEM*\n\nEl comportamiento de un fenómeno en un sistema depende de la geometría o dominio del sistema, la propiedad del material o medio y las condiciones de frontera, iniciales y de carga. Para un sistema de ingeniería, la geometría o el dominio pueden ser muy complejos. Además, la frontera y las condiciones iniciales también pueden ser complicadas. Por lo tanto, en general, es muy difícil resolver la ecuación diferencial gobernante por medios analíticos. En la práctica, la mayoría de los problemas se resuelven mediante métodos numéricos. Entre estos, los métodos de discretización de dominios propugnados por el FEM son los más populares, debido a su practicidad y versatilidad.\n\n#### Modelado\n\n\n \n
\n\n\n\nEl procedimiento de modelado computacional que utiliza el FEM consta en general de cuatro pasos:\n\n\n- Modelado de la geometría.\n\n\n- [Mallado](https://en.wikipedia.org/wiki/Mesh_generation) (discretización).\n\n\n- Especificación de propiedad material.\n\n\n- Especificación de condiciones de contorno, inicial y de carga.\n\n\n***Ejemplo:*** Elementos unidimensionales\n\n\n \n
\n\n\n\n\n***Ejemplo:*** Elementos bidimensionales\n\n\n \n
\n\n\n\n#### Simulación\n\nLas etapas del proceso de simulación empleando la técnica FEM se puede resumir en la siguiente tabla:\n\n\n \n
\n\n\n\n#### Terminología FEM\n\n- ***Dominio:*** es el conjunto de variables independientes para las que se define una función. En el *FEA*, un dominio es un sistema (región) continuo sobre el cual gobiernan las leyes de la física. En la ingeniería estructural, un dominio podría ser una viga o el marco de un edificio completo. En la ingeniería mecánica, un dominio podría ser una pieza de una máquina o un campo térmico.\n\n\n- ***Ecuaciones gobernantes:*** son las ecuaciones derivadas de la física del sistema. Muchos sistemas de ingeniería pueden describirse mediante ecuaciones de gobierno, que determinan las características y comportamientos del sistema.\n\n\n- ***Condiciones de frontera:*** son valores de la función en el borde del rango de algunas de sus variables. Es necesario conocer algunas de las condiciones de contorno para resolver un problema de ingeniería o para encontrar una función desconocida.\n\n\n- ***Elemento:*** es una parte del dominio del problema y, por lo general, tiene una forma simple como un triángulo o cuadrilátero en 2D, o un tetraedro o un sólido rectangular en 3D.\n\n\n- ***Nodo:*** es un punto en el dominio y, a menudo, es el vértice de varios elementos. Un nodo también se llama punto nodal.\n\n\n- ***Malla:*** los elementos y nodos, juntos, forman una malla (mesh o grid, en inglés), que es la estructura de datos central en FEA.\n\n\n \n
\n\n\n- ***Generación de malla:*** la mayoría del software FEA genera automáticamente una malla refinada para lograr resultados más precisos. Para análisis de elementos finitos complejos o a gran escala, a menudo es imperativo que las computadoras generen una malla de elementos finitos automáticamente. Hay muchos algoritmos diferentes para la generación automática de mallas. En [este enlace](http://www.argusone.com/MeshGeneration.html) podrá ver algunas muestras de malla generadas automáticamente.\n\n\n- ***Análisis lineal:*** se basa en los siguientes supuestos: (1) estático; (2) Pequeños desplazamientos; (3) El material es linealmente elástico.\n\n\n- ***Análisis no lineal:*** considera la no linealidad del material y/o la no linealidad geométrica de un sistema de ingeniería. El análisis geométrico no lineal también se denomina análisis de grandes deformaciones.\n\n\n- ***Grados de libertad:*** Los [grados de libertad](https://en.wikipedia.org/wiki/Degrees_of_freedom_(mechanics)) (DOF) son las principales incógnitas en las ecuaciones que constituyen un modelo de elementos finitos. La resolución de las ecuaciones determina los valores de los grados de libertad para cada nodo del modelo. Estos valores se denominan \"datos primarios\" en la documentación. Los datos derivados (tensiones, deformaciones, gradientes, flujos, etc.) se calculan a partir de la solución DOF. Los DOF incluyen desplazamientos (UX, UY, UZ), rotaciones (ROTX, ROTY, ROTZ), temperatura (TEMP), entre otros. Los grados de libertad incluidos en cada tipo de elemento reflejan la física del problema subyacente. Debe elegir elementos que ofrezcan solo los grados de libertad que necesita, ya que los grados de libertad adicionales aumentan el tiempo de cálculo y no proporcionan ningún beneficio. Por ejemplo, el análisis estructural (generalmente) no implica transferencia de calor o voltajes. Por lo tanto, los elementos utilizados para modelar estructuras no deben tener TEMP o VOLT DOF.\n\n A continuación se presenta una tabla resumen con los DOF más comunes para diferentes tipos de elementos estructurales:\n\n|Elemento| DOFs |\n|:------:|:----------------------------------:|\n|Cercha |$$UX, UY, UZ$$ |\n|Viga |$$UX, UY, UZ; RotX, RotY, RotZ$$|\n|Ladrillo|$$UX, UY, UZ$$ |\n|Placa |$$UX, UY, UZ, Rot2DOFs-plano^*$$ |\n\n $^*$El *DOF* rotacional fuera del plano no se considera para elementos de placa. \n\n\n\n### Pasos en la solución por el FEM\n\nEl desarrollo de un análisis por elementos finitos involucra una serie de pasos hasta determinar las fuerzas nodales y desplazamientos ocurridos en la estructura. A seguir se enuncian, de forma muy general, cada uno de ellos. A lo largo del curso se entrará más en detalle.\n\n#### Discretizar la estructura en elementos. \n\nEstos elementos están conectados entre sí a través de nodos.\n\n\n \n
\n\n\n\n\nEn este primer paso, se compone un modelo matemático de la estructura. Este modelo es una aproximación de la estructura, mientras que la estructura física es continua, el modelo consta de elementos discretos.\n\nEn este ejemplo se utiliza elementos tipo viga que se basan en la [teoría de vigas de Euler-Bernoulli](https://en.wikipedia.org/wiki/Euler%E2%80%93Bernoulli_beam_theory). El elemento tiene $2$ nodos, cada uno de los cuales tiene $3$ grados de libertad: traslación en $x$, traslación en $y$ y rotación.\n\n#### Determinar la matriz de rigidez local para cada elemento\n\nEsta matriz representa la rigidez de cada nodo en el elemento en un grado de libertad específico (es decir, determina el desplazamiento de cada nodo en cada grado de libertad bajo una carga dada). Debido a que cada uno de los nodos en el elemento de viga tiene $3$ grados de libertad, una matriz de $6 \\times 6$ puede describir completamente la rigidez del elemento.\n\n\\begin{equation}\nk^{(e)}=\n\\begin{bmatrix}\n\\frac{AE}{L} & 0 & 0 & -\\frac{AE}{L} & 0 & 0 \\\\\n0 & \\frac{12EI}{L^3} & \\frac{6EI}{L^2} & 0 & -\\frac{12EI}{L^3} & \\frac{6EI}{L^2}\\\\\n0 & \\frac{6EI}{L^2} & \\frac{4EI}{L} & 0 & -\\frac{6EI}{L^2} & \\frac{2EI}{L}\\\\\n-\\frac{AE}{L} & 0 & 0 & \\frac{AE}{L} & 0 & 0 \\\\\n0 & -\\frac{12EI}{L^3} & -\\frac{6EI}{L^2} & 0 & \\frac{12EI}{L^3} & -\\frac{6EI}{L^2}\\\\\n0 & \\frac{6EI}{L^2} & \\frac{2EI}{L} & 0 & -\\frac{6EI}{L^2} & \\frac{4EI}{L}\n\\end{bmatrix}\n\\end{equation}\n\n\n#### Ensamblar la matriz de rigidez global\n\nLa matriz de rigidez global para la estructura general se ensambla basándose en la combinación de las matrices de rigidez local. En un nivel alto, la matriz de rigidez global se crea sumando las matrices de rigidez locales:\n\n$$\\left[ K\\right]=\\sum_i \\left[ k_i^{(e)}\\right]$$\n\ndonde la matriz $[k^{(e)}_i]$ es la matriz de rigidez local del elemento $i$.\n\nLa matriz de rigidez global será una matriz cuadrada $n \\times n$, donde $n$ es $3$ veces el número de nodos en la malla (ya que cada nodo tiene $3$ grados de libertad). Al ensamblar la matriz de rigidez global, los términos de rigidez para cada nodo en la matriz de rigidez elemental se colocan en la ubicación correspondiente en la matriz global. Para cualquier elemento que comparta un nodo, las contribuciones de rigidez de ese nodo se sumarán de cada elemento.\n\n#### Cálcular el vector de fuerza aplicada\n\nEl vector de fuerza aplicada será un vector $n \\times 1$, donde $n$ es $3$ veces el número de nodos en la malla. El vector de fuerza se ensambla incluyendo las fuerzas aplicadas en cada grado de libertad en cada nodo de la malla:\n\n$$\\left\\{ F\\right\\} =\\sum_i \\left\\{ f_i^{(e)} \\right\\}$$\n\nUna vez que se construyen la matriz de rigidez global y el vector de fuerza aplicada, se pueden resolver los desplazamientos nodales. La siguiente ecuación relaciona las fuerzas y los desplazamientos en la estructura general:\n\n$$\\left\\{F\\right\\}+\\left\\{R\\right\\}=\\left[K\\right]\\left\\{U\\right\\}$$\n\ndonde \n\n- $\\left\\{F\\right\\}$ es el vector de fuerza aplicada, \n\n\n- $\\left\\{R\\right\\}$ es el vector de reacción externa, \n\n\n- $\\left[K\\right]$ es la matriz de rigidez global, y\n\n\n- $\\left\\{U\\right\\}$ es el vector de desplazamiento nodal.\n\nEn la ecuación anterior, $\\left\\{R\\right\\}$ y $\\left\\{U\\right\\}$ son incógnitas. Para simplificar la solución de esta ecuación, se desea resolver las reacciones y los desplazamientos independientemente unos de otros. Para hacer esto, podemos usar el hecho de que para cada restricción que se aplicó (ya sea una restricción en traslación en $x$, traslación en $y$, o rotación), el desplazamiento asociado con esa restricción será cero. Además, las reacciones externas solo ocurrirán donde se aplicaron restricciones. Por lo tanto, se sabe que para cada grado de libertad en cada nodo:\n\n- Si se aplica una restricción, el desplazamiento en esa restricción será cero y la reacción externa puede ser distinta de cero.\n\n\n- Si no hay restricción, la reacción externa será cero y el desplazamiento puede ser distinto de cero.\n\n#### Aplicar condiciones de contorno y resolver los desplazamientos nodales\n\nInicialmente resolveremos la ecuación anterior para los desplazamientos nodales, $\\left\\{U\\right\\}$. Con base en el razonamiento anterior, es posible eliminar el vector $\\left\\{R\\right\\}$ de la ecuación. Las condiciones de contorno se aplican a la ecuación \"poniendo a cero\" las filas en las matrices correspondientes a las restricciones aplicadas. Al hacer esto, no hemos perdido ninguna información sobre los desplazamientos nodales, ya que se sabe que los desplazamientos serán cero para cada fila que se puso a cero. Ahora la ecuación se ha reducido a:\n\n$$\\left\\{F\\right\\}=\\left[K\\right]\\left\\{U\\right\\}$$\n\n#### Resolver las reacciones externas\n\nLa ecuación anterior se puede resolver para $\\left\\{U\\right\\}$, después de lo cual se conocen todos los desplazamientos nodales. La única incógnita que queda en la ecuación original es $\\left\\{R\\right\\}$, y esto ahora se puede resolver para:\n\n$$\\left\\{R\\right\\}=\\left[K\\right]\\left\\{U\\right\\}-\\left\\{F\\right\\}$$\n\nAhora es posible resolver las fuerzas en cada nodo.\n\n#### Resolver las fuerzas nodales\n\nPara cualquier fuerza de reacción encontrada, la fuerza nodal es igual a la fuerza de reacción. Sin embargo, para los nodos donde no hay una reacción externa, las fuerzas en el nodo aún se desconocen. Estos se pueden encontrar extrayendo los desplazamientos apropiados del vector $\\left\\{U\\right\\}$ global para construir un vector $\\left\\{u\\right\\}$ local para cada elemento. Cada uno de estos vectores locales será un $6 \\times 1$. Las fuerzas nodales en cada elemento se pueden resolver usando:\n\n$$\\left\\{f\\right\\} = \\left[k\\right] \\left\\{u\\right\\}$$\n\ndonde \n\n- $\\left\\{f\\right\\}$ es el vector de fuerza del elemento (local), \n\n\n- $\\left[k\\right]$ es la matriz de rigidez del elemento, y \n\n\n- $\\left\\{u\\right\\}$ es el vector de desplazamiento del elemento. \n\n#### Resolver las tensiones\n\nUna vez que se conocen las fuerzas en cada nodo de la malla, es posible resolver los esfuerzo en cada nodo:\n\n| Esfuerzo axial |Esfuerzo cortante|Esfuerzo a flexión|Esfuerzos de von Mises|\n|:--------------:|:---------------:|:----------------:|:--------------------:|\n|$$\\sigma_{ax}=\\frac{F_{ax}}{A}$$ |$$\\tau_{sh}=\\frac{F_{sh}}{A}$$|$$\\sigma_b=\\frac{Mc}{I}$$|$$\\sigma_{vm}=\\sqrt{(\\sigma_{ax}+\\sigma_b)^2+3\\tau_{sh}^2}$$|\n\n\n\n\n### Atributos de elementos\n\nExiste una ámplia tecnología de elementos en el FEM. Entre los tipos de elementos más comunes se tienen:\n\n\n \n
\n\nen la siguiente imágen se observa la comparación entre un componente estructural físico y su equivalente a un elemento finito idealizado\n\n\n \n
\n\n\n\n\n\n### Aspectos computacionales del FEM\n\nComing soon...\n\n\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open('./nb_style.css', 'r').read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n \n$$Pr(X=x)=\\frac{e^{-\\lambda}\\lambda^x}{x!}$$\n
\n\n* $X=\\{0,1,2,\\ldots\\}$\n* $\\lambda > 0$\n\n$$E(X) = \\text{Var}(X) = \\lambda$$\n\n### Continuous Random Variables\n\n$$X \\in [0,1]$$\n\n$$Y \\in (-\\infty, \\infty)$$\n\n**Probability Density Function**: \n\nFor continuous $X$,\n\n$$Pr(x \\le X \\le x + dx) = f(x|\\theta)dx \\, \\text{ as } \\, dx \\rightarrow 0$$\n\n\n\n***e.g. normal distribution***\n\n \n$$f(x) = \\frac{1}{\\sqrt{2\\pi\\sigma^2}}\\exp\\left[-\\frac{(x-\\mu)^2}{2\\sigma^2}\\right]$$\n
\n\n* $X \\in \\mathbf{R}$\n* $\\mu \\in \\mathbf{R}$\n* $\\sigma>0$\n\n$$\\begin{align}E(X) &= \\mu \\cr\n\\text{Var}(X) &= \\sigma^2 \\end{align}$$\n\n### Example: Nashville Precipitation\n\nThe dataset `nashville_precip.txt` contains [NOAA precipitation data for Nashville measured since 1871](http://bit.ly/nasvhville_precip_data). \n\n\n\nThe gamma distribution is often a good fit to aggregated rainfall data, and will be our candidate distribution in this case.\n\n\n```python\nprecip = pd.read_table(\"../data/nashville_precip.txt\", index_col=0, na_values='NA', delim_whitespace=True)\nprecip.head()\n```\n\n\n\n\n\n
\n \n \n Jan \n Feb \n Mar \n Apr \n May \n Jun \n Jul \n Aug \n Sep \n Oct \n Nov \n Dec \n \n \n Year \n \n \n \n \n 1871 \n 2.76 \n 4.58 \n 5.01 \n 4.13 \n 3.30 \n 2.98 \n 1.58 \n 2.36 \n 0.95 \n 1.31 \n 2.13 \n 1.65 \n \n \n 1872 \n 2.32 \n 2.11 \n 3.14 \n 5.91 \n 3.09 \n 5.17 \n 6.10 \n 1.65 \n 4.50 \n 1.58 \n 2.25 \n 2.38 \n \n \n 1873 \n 2.96 \n 7.14 \n 4.11 \n 3.59 \n 6.31 \n 4.20 \n 4.63 \n 2.36 \n 1.81 \n 4.28 \n 4.36 \n 5.94 \n \n \n 1874 \n 5.22 \n 9.23 \n 5.36 \n 11.84 \n 1.49 \n 2.87 \n 2.65 \n 3.52 \n 3.12 \n 2.63 \n 6.12 \n 4.19 \n \n \n 1875 \n 6.15 \n 3.06 \n 8.14 \n 4.22 \n 1.73 \n 5.63 \n 8.12 \n 1.60 \n 3.79 \n 1.25 \n 5.46 \n 4.30 \n \n \n
\n
\n$$x \\sim \\text{Gamma}(\\alpha, \\beta) = \\frac{\\beta^{\\alpha}x^{\\alpha-1}e^{-\\beta x}}{\\Gamma(\\alpha)}$$\n
\n\n\n\nThe ***method of moments*** simply assigns the empirical mean and variance to their theoretical counterparts, so that we can solve for the parameters.\n\nSo, for the gamma distribution, the mean and variance are:\n\n \n$$ \\hat{\\mu} = \\bar{X} = \\alpha \\beta $$\n$$ \\hat{\\sigma}^2 = S^2 = \\alpha \\beta^2 $$\n
\n\nSo, if we solve for these parameters, we can use a gamma distribution to describe our data:\n\n \n$$ \\alpha = \\frac{\\bar{X}^2}{S^2}, \\, \\beta = \\frac{S^2}{\\bar{X}} $$\n
\n\nLet's deal with the missing value in the October data. Given what we are trying to do, it is most sensible to fill in the missing value with the average of the available values. We will learn more sophisticated methods for handling missing data later in the course.\n\n\n```python\nprecip.fillna(value={'Oct': precip.Oct.mean()}, inplace=True)\n```\n\n\n\n\n\n
\n \n \n Jan \n Feb \n Mar \n Apr \n May \n Jun \n Jul \n Aug \n Sep \n Oct \n Nov \n Dec \n \n \n Year \n \n \n \n \n 1871 \n 2.76 \n 4.58 \n 5.01 \n 4.13 \n 3.30 \n 2.98 \n 1.58 \n 2.36 \n 0.95 \n 1.31 \n 2.13 \n 1.65 \n \n \n 1872 \n 2.32 \n 2.11 \n 3.14 \n 5.91 \n 3.09 \n 5.17 \n 6.10 \n 1.65 \n 4.50 \n 1.58 \n 2.25 \n 2.38 \n \n \n 1873 \n 2.96 \n 7.14 \n 4.11 \n 3.59 \n 6.31 \n 4.20 \n 4.63 \n 2.36 \n 1.81 \n 4.28 \n 4.36 \n 5.94 \n \n \n 1874 \n 5.22 \n 9.23 \n 5.36 \n 11.84 \n 1.49 \n 2.87 \n 2.65 \n 3.52 \n 3.12 \n 2.63 \n 6.12 \n 4.19 \n \n \n 1875 \n 6.15 \n 3.06 \n 8.14 \n 4.22 \n 1.73 \n 5.63 \n 8.12 \n 1.60 \n 3.79 \n 1.25 \n 5.46 \n 4.30 \n \n \n 1876 \n 6.41 \n 2.22 \n 5.28 \n 3.62 \n 3.40 \n 5.65 \n 7.15 \n 5.77 \n 2.52 \n 2.68 \n 1.26 \n 0.95 \n \n \n 1877 \n 4.05 \n 1.06 \n 4.98 \n 9.47 \n 1.25 \n 6.02 \n 3.25 \n 4.16 \n 5.40 \n 2.61 \n 4.93 \n 2.49 \n \n \n 1878 \n 3.34 \n 2.10 \n 3.48 \n 6.88 \n 2.33 \n 3.28 \n 9.43 \n 5.02 \n 1.28 \n 2.17 \n 3.20 \n 6.04 \n \n \n 1879 \n 6.32 \n 3.13 \n 3.81 \n 2.88 \n 2.88 \n 2.50 \n 8.47 \n 4.62 \n 5.18 \n 2.90 \n 5.85 \n 9.15 \n \n \n 1880 \n 3.74 \n 12.37 \n 8.16 \n 5.26 \n 4.13 \n 3.97 \n 5.69 \n 2.22 \n 5.39 \n 7.24 \n 5.77 \n 3.32 \n \n \n 1881 \n 3.54 \n 5.48 \n 2.79 \n 5.12 \n 3.67 \n 3.70 \n 0.86 \n 1.81 \n 6.57 \n 4.80 \n 4.89 \n 4.85 \n \n \n 1882 \n 14.51 \n 8.61 \n 9.38 \n 3.59 \n 7.38 \n 2.54 \n 4.06 \n 5.54 \n 1.61 \n 1.11 \n 3.60 \n 1.52 \n \n \n 1883 \n 3.76 \n 7.90 \n 3.98 \n 9.12 \n 4.82 \n 3.82 \n 4.94 \n 4.47 \n 2.23 \n 5.27 \n 3.11 \n 4.97 \n \n \n 1884 \n 7.20 \n 8.18 \n 8.89 \n 3.51 \n 3.58 \n 6.53 \n 3.18 \n 2.81 \n 2.36 \n 2.43 \n 1.57 \n 3.78 \n \n \n 1885 \n 6.29 \n 2.00 \n 2.33 \n 3.75 \n 4.36 \n 3.72 \n 5.26 \n 1.02 \n 5.60 \n 2.99 \n 2.73 \n 2.90 \n \n \n 1886 \n 5.18 \n 3.82 \n 4.76 \n 2.36 \n 2.10 \n 7.69 \n 1.90 \n 5.50 \n 3.68 \n 0.51 \n 5.76 \n 1.48 \n \n \n 1887 \n 5.13 \n 8.47 \n 3.36 \n 2.67 \n 3.43 \n 2.31 \n 3.77 \n 2.89 \n 6.85 \n 1.92 \n 2.29 \n 5.31 \n \n \n 1888 \n 6.29 \n 3.78 \n 6.46 \n 4.18 \n 2.97 \n 4.68 \n 2.36 \n 7.03 \n 3.82 \n 2.82 \n 4.33 \n 1.77 \n \n \n 1889 \n 3.83 \n 1.84 \n 2.47 \n 2.83 \n 5.30 \n 5.33 \n 2.74 \n 1.57 \n 6.81 \n 1.54 \n 6.88 \n 1.17 \n \n \n 1890 \n 8.10 \n 10.95 \n 8.64 \n 3.84 \n 4.16 \n 2.23 \n 0.46 \n 6.59 \n 5.86 \n 3.01 \n 2.01 \n 4.12 \n \n \n 1891 \n 6.15 \n 6.96 \n 10.31 \n 2.24 \n 2.39 \n 6.50 \n 1.49 \n 3.72 \n 1.25 \n 0.84 \n 6.71 \n 4.26 \n \n \n 1892 \n 2.81 \n 2.73 \n 4.10 \n 7.45 \n 4.03 \n 5.01 \n 5.13 \n 3.39 \n 4.78 \n 0.25 \n 3.91 \n 6.43 \n \n \n 1893 \n 1.27 \n 4.88 \n 3.37 \n 4.11 \n 7.31 \n 4.74 \n 2.12 \n 1.92 \n 6.43 \n 3.68 \n 2.97 \n 3.50 \n \n \n 1894 \n 4.28 \n 8.65 \n 2.69 \n 4.05 \n 2.53 \n 3.55 \n 5.45 \n 2.43 \n 3.07 \n 0.53 \n 1.92 \n 2.81 \n \n \n 1895 \n 5.71 \n 0.98 \n 5.09 \n 3.07 \n 2.05 \n 2.90 \n 7.14 \n 1.40 \n 6.69 \n 1.57 \n 2.14 \n 4.09 \n \n \n 1896 \n 1.37 \n 3.65 \n 6.45 \n 2.92 \n 4.05 \n 1.82 \n 7.33 \n 1.40 \n 2.74 \n 0.98 \n 5.71 \n 1.79 \n \n \n 1897 \n 3.13 \n 3.84 \n 8.49 \n 5.79 \n 1.22 \n 1.82 \n 8.53 \n 2.34 \n 0.19 \n 0.92 \n 2.83 \n 4.93 \n \n \n 1898 \n 9.46 \n 0.63 \n 5.36 \n 3.16 \n 1.80 \n 4.97 \n 4.50 \n 6.56 \n 4.87 \n 3.21 \n 3.09 \n 2.41 \n \n \n 1899 \n 5.59 \n 5.19 \n 7.81 \n 3.25 \n 3.36 \n 0.75 \n 6.44 \n 2.53 \n 1.50 \n 1.83 \n 1.55 \n 4.64 \n \n \n 1900 \n 2.61 \n 3.80 \n 2.20 \n 4.04 \n 1.86 \n 10.35 \n 2.87 \n 1.24 \n 4.55 \n 3.93 \n 8.87 \n 2.22 \n \n \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n \n \n 1982 \n 6.50 \n 4.80 \n 3.00 \n 4.36 \n 4.19 \n 2.28 \n 5.47 \n 3.46 \n 3.23 \n 1.91 \n 3.87 \n 6.36 \n \n \n 1983 \n 2.56 \n 2.93 \n 3.44 \n 6.80 \n 11.04 \n 3.93 \n 1.71 \n 1.36 \n 0.45 \n 2.77 \n 6.98 \n 7.75 \n \n \n 1984 \n 1.79 \n 2.38 \n 5.14 \n 8.41 \n 9.68 \n 4.49 \n 6.63 \n 2.42 \n 0.97 \n 6.00 \n 6.20 \n 2.38 \n \n \n 1985 \n 3.02 \n 3.30 \n 2.70 \n 2.91 \n 2.65 \n 1.53 \n 2.00 \n 3.91 \n 2.52 \n 1.59 \n 3.81 \n 0.98 \n \n \n 1986 \n 0.19 \n 3.59 \n 2.29 \n 0.52 \n 3.36 \n 2.38 \n 0.77 \n 3.38 \n 2.19 \n 2.19 \n 7.43 \n 3.31 \n \n \n 1987 \n 1.61 \n 4.87 \n 1.18 \n 1.03 \n 4.41 \n 2.82 \n 2.56 \n 0.73 \n 1.95 \n 0.21 \n 3.40 \n 5.46 \n \n \n 1988 \n 3.73 \n 2.02 \n 2.18 \n 2.09 \n 1.86 \n 0.45 \n 3.26 \n 2.39 \n 2.45 \n 1.54 \n 5.49 \n 3.95 \n \n \n 1989 \n 4.52 \n 9.36 \n 5.31 \n 2.68 \n 4.61 \n 7.87 \n 3.18 \n 3.67 \n 6.30 \n 3.62 \n 3.94 \n 1.97 \n \n \n 1990 \n 2.76 \n 4.73 \n 3.26 \n 1.60 \n 2.80 \n 2.37 \n 4.86 \n 3.12 \n 2.13 \n 4.41 \n 4.29 \n 10.76 \n \n \n 1991 \n 2.92 \n 5.44 \n 4.25 \n 3.35 \n 5.63 \n 1.25 \n 2.82 \n 1.79 \n 5.47 \n 3.88 \n 2.87 \n 7.27 \n \n \n 1992 \n 2.97 \n 2.60 \n 4.50 \n 0.77 \n 3.12 \n 4.31 \n 5.89 \n 3.25 \n 3.45 \n 1.62 \n 4.48 \n 2.88 \n \n \n 1993 \n 2.76 \n 3.33 \n 5.50 \n 3.33 \n 4.50 \n 5.31 \n 3.64 \n 1.76 \n 2.90 \n 2.20 \n 2.53 \n 6.62 \n \n \n 1994 \n 4.36 \n 6.18 \n 7.56 \n 5.72 \n 3.76 \n 8.08 \n 4.82 \n 5.05 \n 4.20 \n 3.31 \n 4.04 \n 2.69 \n \n \n 1995 \n 5.61 \n 1.81 \n 3.87 \n 3.95 \n 7.66 \n 3.69 \n 1.95 \n 3.40 \n 5.00 \n 5.60 \n 3.98 \n 2.32 \n \n \n 1996 \n 3.82 \n 2.46 \n 5.15 \n 3.68 \n 4.48 \n 3.68 \n 5.45 \n 1.09 \n 4.88 \n 3.16 \n 6.00 \n 4.77 \n \n \n 1997 \n 4.19 \n 3.10 \n 9.64 \n 2.42 \n 4.92 \n 6.66 \n 3.26 \n 3.52 \n 5.75 \n 2.71 \n 6.59 \n 2.19 \n \n \n 1998 \n 3.68 \n 4.11 \n 3.13 \n 6.31 \n 4.46 \n 11.95 \n 4.63 \n 2.93 \n 1.39 \n 1.59 \n 1.30 \n 6.53 \n \n \n 1999 \n 9.28 \n 2.33 \n 4.27 \n 2.29 \n 4.35 \n 3.56 \n 3.19 \n 3.05 \n 1.97 \n 2.04 \n 2.99 \n 2.50 \n \n \n 2000 \n 3.52 \n 3.75 \n 3.34 \n 6.23 \n 7.66 \n 1.74 \n 2.25 \n 1.95 \n 1.90 \n 0.26 \n 6.39 \n 3.44 \n \n \n 2001 \n 3.21 \n 8.54 \n 2.73 \n 2.42 \n 5.54 \n 4.47 \n 2.77 \n 4.07 \n 1.79 \n 4.61 \n 5.09 \n 3.32 \n \n \n 2002 \n 4.93 \n 1.99 \n 9.40 \n 4.31 \n 3.98 \n 3.76 \n 5.64 \n 3.13 \n 6.29 \n 4.48 \n 2.91 \n 5.81 \n \n \n 2003 \n 1.59 \n 8.47 \n 2.30 \n 4.69 \n 10.73 \n 7.08 \n 2.87 \n 3.88 \n 8.70 \n 1.80 \n 4.17 \n 3.19 \n \n \n 2004 \n 3.60 \n 5.77 \n 4.81 \n 6.69 \n 6.90 \n 3.39 \n 3.19 \n 4.24 \n 4.55 \n 4.90 \n 5.21 \n 5.93 \n \n \n 2005 \n 4.42 \n 3.84 \n 3.90 \n 6.93 \n 1.03 \n 2.70 \n 2.39 \n 6.89 \n 1.44 \n 0.02 \n 3.29 \n 2.46 \n \n \n 2006 \n 6.57 \n 2.69 \n 2.90 \n 4.14 \n 4.95 \n 2.19 \n 2.64 \n 5.20 \n 4.00 \n 2.98 \n 4.05 \n 3.41 \n \n \n 2007 \n 3.32 \n 1.84 \n 2.26 \n 2.75 \n 3.30 \n 2.37 \n 1.47 \n 1.38 \n 1.99 \n 4.95 \n 6.20 \n 3.83 \n \n \n 2008 \n 4.76 \n 2.53 \n 5.56 \n 7.20 \n 5.54 \n 2.21 \n 4.32 \n 1.67 \n 0.88 \n 5.03 \n 1.75 \n 6.72 \n \n \n 2009 \n 4.59 \n 2.85 \n 2.92 \n 4.13 \n 8.45 \n 4.53 \n 6.03 \n 2.14 \n 11.08 \n 6.49 \n 0.67 \n 3.99 \n \n \n 2010 \n 4.13 \n 2.77 \n 3.52 \n 3.48 \n 16.43 \n 4.96 \n 5.86 \n 6.99 \n 1.17 \n 2.49 \n 5.41 \n 1.87 \n \n \n 2011 \n 2.31 \n 5.54 \n 4.59 \n 7.51 \n 4.38 \n 5.04 \n 3.46 \n 1.78 \n 6.20 \n 0.93 \n 6.15 \n 4.25 \n \n \n
\n
141 rows × 12 columns
\n
\n$$Pr(Y_i=y_i | \\theta)$$\n
\n\nHere, for example, is a **Poisson distribution** that describes the distribution of some discrete variables, typically *counts*: \n\n\n```python\ny = np.random.poisson(5, size=100)\nplt.hist(y, bins=12, normed=True)\nplt.xlabel('y'); plt.ylabel('Pr(y)')\n```\n\nThe product $\\prod_{i=1}^n Pr(y_i | \\theta)$ gives us a measure of how **likely** it is to observe values $y_1,\\ldots,y_n$ given the parameters $\\theta$. \n\nMaximum likelihood fitting consists of choosing the appropriate function $l= Pr(Y|\\theta)$ to maximize for a given set of observations. We call this function the *likelihood function*, because it is a measure of how likely the observations are if the model is true.\n\n> Given these data, how likely is this model?\n\nIn the above model, the data were drawn from a Poisson distribution with parameter $\\lambda =5$.\n\n$$L(y|\\lambda=5) = \\frac{e^{-5} 5^y}{y!}$$\n\nSo, for any given value of $y$, we can calculate its likelihood:\n\n\n```python\npoisson_like = lambda x, lam: np.exp(-lam) * (lam**x) / (np.arange(x)+1).prod()\n\nlam = 6\nvalue = 10\npoisson_like(value, lam)\n```\n\n\n\n\n 0.041303093412337726\n\n\n\n\n```python\nnp.sum(poisson_like(yi, lam) for yi in y)\n```\n\n\n\n\n 11.499056250911673\n\n\n\n\n```python\nlam = 8\nnp.sum(poisson_like(yi, lam) for yi in y)\n```\n\n\n\n\n 7.8028592304816868\n\n\n\nWe can plot the likelihood function for any value of the parameter(s):\n\n\n```python\nlambdas = np.linspace(0,15)\nx = 5\nplt.plot(lambdas, [poisson_like(x, l) for l in lambdas])\nplt.xlabel('$\\lambda$')\nplt.ylabel('L($\\lambda$|x={0})'.format(x))\n```\n\nHow is the likelihood function different than the probability distribution function (PDF)? The likelihood is a function of the parameter(s) *given the data*, whereas the PDF returns the probability of data given a particular parameter value. Here is the PDF of the Poisson for $\\lambda=5$.\n\n\n```python\nlam = 5\nxvals = np.arange(15)\nplt.bar(xvals, [poisson_like(x, lam) for x in xvals], width=0.2)\nplt.xlabel('x')\nplt.ylabel('Pr(X|$\\lambda$=5)')\n```\n\n*Why are we interested in the likelihood function?*\n\nA reasonable estimate of the true, unknown value for the parameter is one which **maximizes the likelihood function**. So, inference is reduced to an optimization problem.\n\nGoing back to the rainfall data, if we are using a gamma distribution we need to maximize:\n\n$$\\begin{align}l(\\alpha,\\beta) &= \\sum_{i=1}^n \\log[\\beta^{\\alpha} x^{\\alpha-1} e^{-x/\\beta}\\Gamma(\\alpha)^{-1}] \\cr \n&= n[(\\alpha-1)\\overline{\\log(x)} - \\bar{x}\\beta + \\alpha\\log(\\beta) - \\log\\Gamma(\\alpha)]\\end{align}$$\n\n*N.B.: Its usually easier to work in the log scale*\n\nwhere $n = 2012 − 1871 = 141$ and the bar indicates an average over all *i*. We choose $\\alpha$ and $\\beta$ to maximize $l(\\alpha,\\beta)$.\n\nNotice $l$ is infinite if any $x$ is zero. We do not have any zeros, but we do have an NA value for one of the October data, which we dealt with above.\n\n### Finding the MLE\n\nTo find the maximum of any function, we typically take the *derivative* with respect to the variable to be maximized, set it to zero and solve for that variable. \n\n$$\\frac{\\partial l(\\alpha,\\beta)}{\\partial \\beta} = n\\left(\\frac{\\alpha}{\\beta} - \\bar{x}\\right) = 0$$\n\nWhich can be solved as $\\beta = \\alpha/\\bar{x}$. However, plugging this into the derivative with respect to $\\alpha$ yields:\n\n$$\\frac{\\partial l(\\alpha,\\beta)}{\\partial \\alpha} = \\log(\\alpha) + \\overline{\\log(x)} - \\log(\\bar{x}) - \\frac{\\Gamma(\\alpha)'}{\\Gamma(\\alpha)} = 0$$\n\nThis has no closed form solution. We must use ***numerical optimization***!\n\nNumerical optimization alogarithms take an initial \"guess\" at the solution, and **iteratively** improve the guess until it gets \"close enough\" to the answer.\n\nHere, we will use *Newton-Raphson* method, which is a **root-finding algorithm**:\n\n \n$$x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$$\n
\n\nwhich is available to us via SciPy:\n\n\n```python\nfrom scipy.optimize import newton\n```\n\nHere is a graphical example of how Newton-Raphson converges on a solution, using an arbitrary function:\n\n\n```python\n%run newton_raphson_plot.py\n```\n\nTo apply the Newton-Raphson algorithm, we need a function that returns a vector containing the **first and second derivatives** of the function with respect to the variable of interest. The second derivative of the gamma distribution with respect to $\\alpha$ is:\n\n$$\\frac{\\partial^2 l(\\alpha,\\beta)}{\\partial \\alpha^2} = \\frac{1}{\\alpha} - \\frac{\\partial}{\\partial \\alpha} \\left[ \\frac{\\Gamma(\\alpha)'}{\\Gamma(\\alpha)} \\right]$$\n\n\n```python\nfrom scipy.special import psi, polygamma\n\ndlgamma = lambda a, log_mean, mean_log: np.log(a) - psi(a) - log_mean + mean_log\ndl2gamma = lambda a, *args: 1./a - polygamma(1, a)\n```\n\nwhere `log_mean` and `mean_log` are $\\log{\\bar{x}}$ and $\\overline{\\log(x)}$, respectively. `psi` and `polygamma` are complex functions of the Gamma function that result when you take first and second derivatives of that function.\n\n\n```python\n# Calculate statistics\nlog_mean = precip.mean().apply(np.log)\nmean_log = precip.apply(np.log).mean()\n```\n\nTime to optimize!\n\n\n```python\n# Alpha MLE for December\nalpha_mle = newton(dlgamma, 2, dl2gamma, args=(log_mean[-1], mean_log[-1]))\nalpha_mle\n```\n\n\n\n\n 3.5189679152399647\n\n\n\nAnd now plug this back into the solution for beta:\n\n \n$$ \\beta = \\frac{\\alpha}{\\bar{X}} $$\n
\n\n\n```python\nbeta_mle = alpha_mle/precip.mean()[-1]\nbeta_mle\n```\n\n\n\n\n 0.84261607548413797\n\n\n\nWe can compare the fit of the estimates derived from MLE to those from the method of moments:\n\n\n```python\ndec = precip.Dec\ndec.hist(normed=True, bins=10, grid=False)\nx = np.linspace(0, dec.max())\nplt.plot(x, gamma.pdf(x, alpha_mom[-1], beta_mom[-1]), 'm-', label='Moment estimator')\nplt.plot(x, gamma.pdf(x, alpha_mle, beta_mle), 'r--', label='ML estimator')\nplt.legend()\n```\n\nFor some common distributions, SciPy includes methods for fitting via MLE:\n\n\n```python\nfrom scipy.stats import gamma\n\ngamma.fit(precip.Dec)\n```\n\n\n\n\n (2.2427517753152308, 0.65494604470188622, 1.570073932063466)\n\n\n\nThis fit is not directly comparable to our estimates, however, because SciPy's `gamma.fit` method fits an odd 3-parameter version of the gamma distribution.\n\n### Model checking\n\nAn informal way of checking the fit of our parametric model is to compare the observed quantiles of the data to those of the theoretical model we are fitting it to. If the model is a good fit, the points should fall on a 45-degree reference line. This is called a **probability plot**.\n\nSciPy includes a `probplot` function that generates probability plots based on the data and a specified distribution.\n\n\n```python\nfrom scipy.stats import probplot\n\nprobplot(precip.Dec, dist=gamma(3.51, scale=0.84), plot=plt);\n```\n\n### Example: truncated distribution\n\nSuppose that we observe $Y$ truncated below at $a$ (where $a$ is known). If $X$ is the distribution of our observation, then:\n\n$$ P(X \\le x) = P(Y \\le x|Y \\gt a) = \\frac{P(a \\lt Y \\le x)}{P(Y \\gt a)}$$\n\n(so, $Y$ is the original variable and $X$ is the truncated variable) \n\nThen X has the density:\n\n$$f_X(x) = \\frac{f_Y (x)}{1−F_Y (a)} \\, \\text{for} \\, x \\gt a$$ \n\nSuppose $Y \\sim N(\\mu, \\sigma^2)$ and $x_1,\\ldots,x_n$ are independent observations of $X$. We can use maximum likelihood to find $\\mu$ and $\\sigma$. \n\nFirst, we can simulate a truncated distribution using a `while` statement to eliminate samples that are outside the support of the truncated distribution.\n\n\n```python\nx = np.random.normal(size=10000)\n\n# Truncation point\na = -1\n\n# Resample until all points meet criterion\nx_small = x < a\nwhile x_small.sum():\n x[x_small] = np.random.normal(size=x_small.sum())\n x_small = x < a\n \n_ = plt.hist(x, bins=100)\n```\n\nWe can construct a log likelihood for this function using the conditional form:\n\n$$f_X(x) = \\frac{f_Y (x)}{1−F_Y (a)} \\, \\text{for} \\, x \\gt a$$ \n\nThe denominator normalizes the truncated distribution so that it integrates to one.\n\n\n```python\nfrom scipy.stats.distributions import norm\n\ntrunc_norm = lambda theta, a, x: -(np.log(norm.pdf(x, theta[0], theta[1])) - \n np.log(1 - norm.cdf(a, theta[0], theta[1]))).sum()\n```\n\nFor this example, we will use an optimization algorithm, the **Nelder-Mead simplex algorithm**. It has a couple of advantages: \n\n- it does not require derivatives\n- it can optimize (minimize) a vector of parameters\n\nSciPy implements this algorithm in its `fmin` function:\n\n\n```python\nfrom scipy.optimize import fmin\n\nfmin(trunc_norm, np.array([1,2]), args=(-1, x))\n```\n\n Optimization terminated successfully.\n Current function value: 11084.885149\n Iterations: 47\n Function evaluations: 88\n\n\n\n\n\n array([ 0.00531007, 1.00652051])\n\n\n\nIn general, simulating data is a terrific way of testing your model before using it with real data.\n\n## Kernel density estimates\n\nIn some instances, we may not be interested in the parameters of a particular distribution of data, but just a smoothed representation of the data at hand. In this case, we can estimate the disribution *non-parametrically* (i.e. making no assumptions about the form of the underlying distribution) using kernel density estimation.\n\n\n```python\n# Some random data\ny = np.random.normal(10, size=15)\ny\n```\n\n\n\n\n array([ 9.68444175, 6.86641455, 8.90236824, 8.48662651,\n 9.4599326 , 9.83248454, 9.45367613, 12.95585035,\n 10.58747989, 10.94829904, 10.48694903, 9.13200438,\n 9.73979452, 10.14852737, 8.62582257])\n\n\n\nThe kernel estimator is a sum of symmetric densities centered at each observation. The selected kernel function determines the shape of each component while the **bandwidth** determines their spread. For example, if we use a Gaussian kernel function, the variance acts as the bandwidth.\n\n\n```python\nx = np.linspace(7, 13, 100)\n# Smoothing parameter\ns = 0.3\n# Calculate the kernels\nkernels = np.transpose([norm.pdf(x, yi, s) for yi in y])\nplt.plot(x, kernels, 'k:')\nplt.plot(x, kernels.sum(1))\nplt.plot(y, np.zeros(len(y)), 'ro', ms=10)\n```\n\nSciPy implements a Gaussian KDE that automatically chooses an appropriate bandwidth. Let's create a bi-modal distribution of data that is not easily summarized by a parametric distribution:\n\n\n```python\n# Create a bi-modal distribution with a mixture of Normals.\nx1 = np.random.normal(0, 2, 50)\nx2 = np.random.normal(5, 1, 50)\n\n# Append by row\nx = np.r_[x1, x2]\n```\n\n\n```python\nplt.hist(x, bins=10, normed=True)\n```\n\n\n```python\nfrom scipy.stats import kde\n\ndensity = kde.gaussian_kde(x)\nxgrid = np.linspace(x.min(), x.max(), 100)\nplt.hist(x, bins=8, normed=True)\nplt.plot(xgrid, density(xgrid), 'r-')\n```\n\n### Exercise: Comparative Chopstick Effectiveness\n\nA few researchers set out to determine what the optimal length for chopsticks is. The dataset `chopstick-effectiveness.csv` includes measurements of \"Food Pinching Efficiency\" across a range of chopstick lengths for 31 individuals.\n\nUse the method of moments or MLE to calculate the mean and variance of food pinching efficiency for each chopstick length. This means you need to select an appropriate distributional form for this data.\n\n\n```python\n# Write your answer here\n```\n", "meta": {"hexsha": "4279f9ec24827f4900084bf9a6f035707f1baad2", "size": 339209, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebooks/2. Density Estimation.ipynb", "max_stars_repo_name": "rouseguy/scipy2015_tutorial", "max_stars_repo_head_hexsha": "6d419dbda904d363192d516c1c8fe1c732c7f69d", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 53, "max_stars_repo_stars_event_min_datetime": "2015-06-20T02:59:05.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-04T22:58:08.000Z", "max_issues_repo_path": "notebooks/2. Density Estimation.ipynb", "max_issues_repo_name": "rouseguy/scipy2015_tutorial", "max_issues_repo_head_hexsha": "6d419dbda904d363192d516c1c8fe1c732c7f69d", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2015-07-05T10:16:00.000Z", "max_issues_repo_issues_event_max_datetime": "2015-07-09T17:18:44.000Z", "max_forks_repo_path": "notebooks/2. Density Estimation.ipynb", "max_forks_repo_name": "fonnesbeck/scipy2015_tutorial", "max_forks_repo_head_hexsha": "6d419dbda904d363192d516c1c8fe1c732c7f69d", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 54, "max_forks_repo_forks_event_min_datetime": "2015-07-03T20:50:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-21T16:04:01.000Z", "avg_line_length": 60.0795253277, "max_line_length": 336, "alphanum_fraction": 0.7303284995, "converted": true, "num_tokens": 15393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.26284184314569564, "lm_q1q2_score": 0.12834130759699547}}
{"text": " \n#### Procesamiento Digital de Señales\n\n# Trabajo Práctico Nº0\n#### Yanina Corsaro\n\n\n# Introducción\nJupyter Notebook es una herramienta para la confección de reportes técnicos, dado que permite la interacción en el mismo ambiente de: \n1. un procesador de texto elemental (formato Markdown) que permite resaltar texto, en forma de *itálica* o **negrita** de manera muy legible (haciendo doble click en este texto podrás ver el código fuente estilo Markdown). Cuenta con estilos predefinidos:\n\n# Título 1\n## Título 2\n### Título 3\n\ny también la capacidad de incluir enlaces a otras páginas, como por ejemplo [esta página](https://medium.com/ibm-data-science-experience/markdown-for-jupyter-notebooks-cheatsheet-386c05aeebed) donde encontrarás más funcionalidades del lenguaje **Markdown**\n\n2. capacidad para incluir lenguaje matemático estilo LaTex, tanto de forma presentada\n\n\\begin{equation}\nT(z) = \\frac{Y(z)}{X(z)} = \\frac{ b_2 \\, z^{-2} + b_1 \\, z^{-1} + b_0 }\n{a_2 \\, z^{-2} + a_1 \\, z^{-1} + a_0}\n\\end{equation}\n\ncomo *inline* en el propio párrafo $y[k] = \\frac{1}{a_0} \\left( \\sum_{m=0}^{M} b_m \\; x[k-m] - \\sum_{n=1}^{N} a_n \\; y[k-n] \\right) $\n\n3. La posibilidad de incluir scripts en Python, como los que usaremos para las simulaciones en los TPs de la materia. En este caso usaremos el *testbench0.py* como ejemplo. Una vez que lo probamos y estamos seguros que funciona de forma esperada en *Spyder*, podemos incluir los resultados de la simulación de manera casi transparente. Solo tenemos que agregar una celda de código donde incluimos el código, y los resultados directamente quedan incluidos en este documento.\n\n\n```python\n# Módulos para Jupyter\nimport warnings\nwarnings.filterwarnings('ignore')\n\nimport numpy as np\nimport matplotlib as mpl\n#%% Inicialización de librerías\n# Setup inline graphics: Esto lo hacemos para que el tamaño de la salida, \n# sea un poco más adecuada al tamaño del documento\nmpl.rcParams['figure.figsize'] = (10,10)\n\nimport matplotlib.pyplot as plt\nimport pdsmodulos as pds\n\n#%% Esto tiene que ver con cuestiones de presentación de los gráficos,\n# NO ES IMPORTANTE\nfig_sz_x = 14\nfig_sz_y = 13\nfig_dpi = 80 # dpi\n\nfig_font_family = 'Ubuntu'\nfig_font_size = 16\n\nplt.rcParams.update({'font.size':fig_font_size})\nplt.rcParams.update({'font.family':fig_font_family})\n\n##############################################\n#%% A partir de aquí comienza lo IMPORTANTE #\n#############################################\n\ndef my_testbench( sig_type ):\n \n # Datos generales de la simulación\n fs = 1000.0 # frecuencia de muestreo (Hz)\n N = 1000 # cantidad de muestras\n \n ts = 1/fs # tiempo de muestreo\n df = fs/N # resolución espectral\n \n # grilla de sampleo temporal\n tt = np.linspace(0, (N-1)*ts, N).flatten()\n \n # grilla de sampleo frecuencial\n ff = np.linspace(0, (N-1)*df, N).flatten()\n\n # Concatenación de matrices:\n # guardaremos las señales creadas al ir poblando la siguiente matriz vacía\n x = np.array([], dtype=np.float).reshape(N,0)\n ii = 0\n \n # estructuras de control de flujo\n if sig_type['tipo'] == 'senoidal':\n \n \n # calculo cada senoidal de acuerdo a sus parámetros\n for this_freq in sig_type['frecuencia']:\n # prestar atención que las tuplas dentro de los diccionarios también pueden direccionarse mediante \"ii\"\n aux = sig_type['amplitud'][ii] * np.sin( 2*np.pi*this_freq*tt + sig_type['fase'][ii] )\n # para concatenar horizontalmente es necesario cuidar que tengan iguales FILAS\n x = np.hstack([x, aux.reshape(N,1)] )\n ii += 1\n \n elif sig_type['tipo'] == 'ruido':\n \n # calculo cada señal de ruido incorrelado (blanco), Gausiano de acuerdo a sus parámetros\n # de varianza\n for this_var in sig_type['varianza']:\n aux = np.sqrt(this_var) * np.random.randn(N,1)\n # para concatenar horizontalmente es necesario cuidar que tengan iguales FILAS\n x = np.hstack([x, aux] )\n \n # Podemos agregar algún dato extra a la descripción de forma programática\n # {0:.3f} significa 0: primer argunmento de format\n # .3f formato flotante, con 3 decimales\n # $ ... $ indicamos que incluiremos sintaxis LaTex: $\\hat{{\\sigma}}^2$\n sig_props['descripcion'] = [ sig_props['descripcion'][ii] + ' - $\\hat{{\\sigma}}^2$ :{0:.3f}'.format( np.var(x[:,ii])) for ii in range(0,len(sig_props['descripcion'])) ]\n \n else:\n \n print(\"Tipo de señal no implementado.\") \n return\n \n #%% Presentación gráfica de los resultados\n \n plt.figure(1)\n line_hdls = plt.plot(tt, x)\n plt.title('Señal: ' + sig_type['tipo'] )\n plt.xlabel('tiempo [segundos]')\n plt.ylabel('Amplitud [V]')\n # plt.grid(which='both', axis='both')\n \n # presentar una leyenda para cada tipo de señal\n axes_hdl = plt.gca()\n \n # este tipo de sintaxis es *MUY* de Python\n axes_hdl.legend(line_hdls, sig_type['descripcion'], loc='upper right' )\n \n plt.show()\n\n```\n\nDado que nuestro *testbench* ha sido desarrollado de manera funcional, llamando a la función *my_testbench()* con diferentes parámetros, podemos lograr funcionalidades diferentes, como mostramos a continuación primero con una senoidal:\n\n\n```python\nsig_props = { 'tipo': 'senoidal', \n 'frecuencia': (3, 10, 20), # Uso de tuplas para las frecuencias \n 'amplitud': (1, 1, 1),\n 'fase': (0, 0, 0)\n } \nsig_props2 = { 'tipo': 'senoidal', \n 'frecuencia': (3, 10, 20), # Uso de tuplas para las frecuencias \n 'amplitud': (1, 1, 1),\n 'fase': (10, 5, 0)\n } \n# Como también puedo agregar un campo descripción de manera programática\n# este tipo de sintaxis es *MUY* de Python\nsig_props['descripcion'] = [ str(a_freq) + ' Hz' for a_freq in sig_props['frecuencia'] ]\nsig_props2['descripcion'] = [ str(a_freq) + ' Hz' for a_freq in sig_props['frecuencia'] ] \n# Invocamos a nuestro testbench exclusivamente: \nmy_testbench( sig_props )\nmy_testbench( sig_props2 )\n```\n\nY ahora con una señal aleatoria, en este caso ruido blanco Gaussiano incorrelado de varianza $\\sigma^2$:\n\n\n```python\n# Usar CTRL+1 para comentar o descomentar el bloque de abajo.\nsig_props = { 'tipo': 'ruido', \n 'varianza': (1, 1, 1) # Uso de tuplas para las frecuencias \n } \nsig_props['descripcion'] = [ '$\\sigma^2$ = ' + str(a_var) for a_var in sig_props['varianza'] ]\n \n# Invocamos a nuestro testbench exclusivamente: \nmy_testbench( sig_props )\n\n```\n\nComo puede verse en la figura anterior, al samplear una distribución estadística de media nula y varianza $\\sigma^2=1$, obtenemos realizaciones cuyo parámetro $\\sigma^2$ estimado, es decir $\\hat\\sigma^2$, tienen una desviación respecto al verdadero valor (sesgo). Nos ocuparemos de estudiar el sesgo y la varianza de algunos estimadores cuando veamos **Estimación Espectral**.\n\n# Una vez terminado ...\nUna vez que hayas termiando con la confección del documento, podemos utilizar una ventaja muy importante de este tipo de documentos que es la posibilidad de compartirlos *online* mediante la [página de nbviewer](http://nbviewer.jupyter.org/). Para ello es necesario que tu notebook y todos los recursos asociados estén alojados en un repositorio de [Github](https://github.com/). Como ejemplo, podés ver este mismo documento disponible [online](http://nbviewer.jupyter.org/github/marianux/pdstestbench/blob/master/notebook0.ipynb).\n\n# Título de prueba\n\nAgregué mi nombre y corrí el código para que aparezcan las imágenes. También agregue otra señal cambiando arbitrariamente la fase.\n\n", "meta": {"hexsha": "373c25774a954eef031471805d2deac546f14e61", "size": 475665, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook.ipynb", "max_stars_repo_name": "yaninacorsaro/test", "max_stars_repo_head_hexsha": "2e0c35d1e2e875beb1537c78470ce7f56518b4cb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "notebook.ipynb", "max_issues_repo_name": "yaninacorsaro/test", "max_issues_repo_head_hexsha": "2e0c35d1e2e875beb1537c78470ce7f56518b4cb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "notebook.ipynb", "max_forks_repo_name": "yaninacorsaro/test", "max_forks_repo_head_hexsha": "2e0c35d1e2e875beb1537c78470ce7f56518b4cb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 1634.587628866, "max_line_length": 166068, "alphanum_fraction": 0.9602283119, "converted": true, "num_tokens": 2167, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.26894142136999516, "lm_q1q2_score": 0.12817200875308135}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! **Bayesian inference is simply updating your beliefs after considering new evidence.** A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, **we can never be 100% sure that our code is bug-free unless we test it on every possible problem**; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by **preserving *uncertainty***. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: ***Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title)**. For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of ***belief***, or **confidence**, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, **I assigned the belief (probability) measure to an *individual*, not to Nature**. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, **we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability***.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\n**It's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence** (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, **for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty*** that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and **our uncertainty is proportional to the width of the curve**. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability **distribution** function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability **mass** function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\n**We will use this property often, so it's useful to remember**. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability **density** function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. **A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data**. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n Multiprocess sampling (4 chains in 4 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n Sampling 4 chains: 100%|██████████| 60000/60000 [00:13<00:00, 4577.12draws/s]\n The number of effective samples is smaller than 25% for some parameters.\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\n**Notice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential**. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\nlambda_1_samples.mean(), lambda_2_samples.mean()\n```\n\n\n\n\n (17.760179819690123, 22.710926545663497)\n\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n#type your code here.\n(lambda_1_samples/lambda_2_samples).mean()\n```\n\n\n\n\n 0.7832074809697906\n\n\n\n\n```python\nlambda_1_samples.mean()/lambda_2_samples.mean()\n```\n\n\n\n\n 0.7820103589336522\n\n\n\nPS to myself: Note that the results returned are different !\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n#type your code here.\nidx = tau_samples < 45\nlambda_1_samples[idx].mean()\n```\n\n\n\n\n 17.757353124712516\n\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "09c222405244e55dc877caa546e30a031e7b27f2", "size": 301422, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "abarbosa94/bayesian_methods_hackers", "max_stars_repo_head_hexsha": "55713602fb823a5524d2ed078ac070f75c9ef28d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-09T00:44:57.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-09T00:44:57.000Z", "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "abarbosa94/bayesian_methods_hackers", "max_issues_repo_head_hexsha": "55713602fb823a5524d2ed078ac070f75c9ef28d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "abarbosa94/bayesian_methods_hackers", "max_forks_repo_head_hexsha": "55713602fb823a5524d2ed078ac070f75c9ef28d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 262.56271777, "max_line_length": 90704, "alphanum_fraction": 0.8980134164, "converted": true, "num_tokens": 11586, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014734858584286, "lm_q2_score": 0.2974699363766584, "lm_q1q2_score": 0.127955904416419}}
{"text": "```python\n%run common-imports.ipynb\n```\n\n\n\n\n\n\n[Back to ATM 623 notebook home](../index.ipynb)\n
\n\n____________\n## Version information\n____________\n\n\n\n```python\n%install_ext http://raw.github.com/jrjohansson/version_information/master/version_information.py\n%load_ext version_information\n%version_information numpy, sympy, climlab\n```\n\n Installed version_information.py. To use it, type:\n %load_ext version_information\n\n\n\n\n\nSoftware Version Python 2.7.9 64bit [GCC 4.2.1 (Apple Inc. build 5577)] IPython 3.1.0 OS Darwin 14.3.0 x86_64 i386 64bit numpy 1.9.2 sympy 0.7.6 climlab 0.2.11 Thu May 14 16:02:40 2015 EDT
\n\n\n\n____________\n## Credits\n\nThe author of this notebook is [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n\nIt was developed in support of [ATM 623: Climate Modeling](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/), a graduate-level course in the [Department of Atmospheric and Envionmental Sciences](http://www.albany.edu/atmos/index.php), offered in Spring 2015.\n____________\n", "meta": {"hexsha": "cda06841e0b2185547d0b6d5aef551c60b0b8643", "size": 545154, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture06 -- Elementary greenhouse models.ipynb", "max_stars_repo_name": "gavin971/ClimateModeling_courseware", "max_stars_repo_head_hexsha": "9c8b446d6a274d88868c24570155f50c32d27b89", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2017-12-06T04:36:30.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-02T13:16:02.000Z", "max_issues_repo_path": "Lectures/Lecture06 -- Elementary greenhouse models.ipynb", "max_issues_repo_name": "gavin971/ClimateModeling_courseware", "max_issues_repo_head_hexsha": "9c8b446d6a274d88868c24570155f50c32d27b89", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture06 -- Elementary greenhouse models.ipynb", "max_forks_repo_name": "gavin971/ClimateModeling_courseware", "max_forks_repo_head_hexsha": "9c8b446d6a274d88868c24570155f50c32d27b89", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-08-09T04:03:45.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-20T11:28:17.000Z", "avg_line_length": 360.7902051621, "max_line_length": 287522, "alphanum_fraction": 0.9120560429, "converted": true, "num_tokens": 6024, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.26588047891687405, "lm_q1q2_score": 0.12671322586684688}}
{"text": "# Chapter 8: Tree-Based Methods\n- **Chapter 8 from the book [An Introduction to Statistical Learning](https://www.statlearning.com/)**\n- **By Gareth James, Daniela Witten, Trevor Hastie and Rob Tibshirani**\n- **Pages from $332$ to $333$**\n- **By [Mosta Ashour](https://www.linkedin.com/in/mosta-ashour/)**\n\n\n**Exercises:**\n- **[1.](#1)**\n- **[2.](#2)**\n- **[3.](#3)**\n- **[4.](#4) [(a)](#4a) [(b)](#4b)**\n- **[5.](#5)**\n- **[6.](#6)**\n\n# 8.4 Exercises \n## Conceptual \n\nt4] R3 R5 R6 R7 [x1\n### $2.$ It is mentioned in Section $8.2.3$ that boosting using depth-one trees (or *stumps*) leads to an *additive* model: that is, a model of the form\n\n$$f(X) = \\sum_{j=1}^{p}{f_j(X_j)}$$\n\n### Explain why this is the case. You can begin with $(8.12)$ in Algorithm $8.2$.\n\n**Answer:**\n>- Boosting has three tuning parameters which the third one is: the number $d$ of splits in each tree, which controls the complexity of the boosted ensemble.\n>- When $d = 1$, each tree is a *stump*, consisting of a *single split*.\n>- In this case, the boosted ensemble is fitting an additive model, since each term involves only a single variable.\n>- With this setting the Boosting for Regression Trees algorithm becomes:\n> 1. Set $\\hat{f}(x) = 0$ and $r_i = y_i$ for all $i$ in training set.\n> 2. For $b = 1, 2, ..., B,$ repeat:\n> $(a)$ Fit a tree $\\hat{f^b}$ with **1** split to the training data $(X, r)$.
\n> $(b)$ Update $\\hat{f}$ by adding the new tree:
\n> $$\\hat{f}(x) \\leftarrow \\hat{f}(x) + \\hat{f}^b(X_j)$$
**Note:** it can't be shrunken because it is already as small as it can possibly be, also note that it is a function of a single variable.
\n> $(c)$ Update the residuals,\n> $$r_i \\leftarrow r_i - \\hat{f}^b(X_j)$$\n> 3. Output the boosted model,\n$$\\hat{f}(x) = \\sum_{b=1}^{B}{\\hat{f}^b(X_j)}$$\n>- Because the model is using depth-one trees, each $\\hat{f}^b$ generated in step $2$ is a function of a single feature $\\hat{f}^b(X_j)$ and so the model output in step $3$ is a sum of functions of a given single variable which is presented as the additive model.\n\n
$$0.1, 0.15, 0.2, 0.2, 0.55, 0.6, 0.6, 0.65, 0.7, \\text{and } 0.75.$$
There are two common ways to combine these results together into a single class prediction. One is the majority vote approach discussed in this chapter. The second approach is to classify based on the average probability. In this example, what is the final classification under each of these two approaches?\n\n\n```python\nres = np.array([0.1, 0.15, 0.2, 0.2, 0.55, 0.6, 0.6, 0.65, 0.7, 0.75])\n\n# Majority vote approach\nmajority = (0.5 < res).sum()\n\n# The average Probability\naverage = np.mean(res)\n\nprint(f'Is red (by Majority): {majority > .5}, majority = {majority}')\nprint(f'Is red (by Average) : {average > .5}, avg = {average}')\n```\n\n Is red (by Majority): True, majority = 6\n Is red (by Average) : False, avg = 0.45\n\n\n
It requires $4$ steps to build a Regression Tree, as shown in Algorithm $8.1$:\n \n> $\\text{Step 1:}$ Use **recursive binary splitting** to grow a large tree on the training data, stopping only when each terminal node has fewer than some minimum number of observations.\n>- We take a top-down, greedy approach that is known as **recursive binary splitting**. The approach is *top-down* because it begins at the top of the tree (at which point all observations belong to a single region) and then successively splits the predictor space; each split is indicated via two new branches further down on the tree. It is *greedy* because at each step of the tree-building process, the best split is made at that particular step, rather than looking ahead and picking a split that will lead to a better tree in some future step.\n>- We first select the predictor $X_j$ and the cutpoint $s$ such that splitting the predictor space into the regions $\\{X|X_j < s\\}$ and $\\{X|X_j \\geq s\\}$ leads to the greatest possible\nreduction in $\\text{RSS}$, and then choose the predictor and cutpoint such that the resulting tree has the lowest $\\text{RSS}$.\n>- Next, we repeat the process, looking for the best predictor and best cutpoint in order to split the data further so as to minimize the $\\text{RSS}$ within each of the resulting regions. \n>- However, this time, instead of splitting the entire predictor space, we split one of the two previously identified regions.\n>- We now have three regions. Again, we look to split one of these three regions further, so as to minimize the $\\text{RSS}$. The process continues until a stopping criterion is reached; for instance, we may continue until no region contains more than five observations \"as in Figure $8.3$\".\n>- Once the regions $R_1, \\dots , R_J$ have been created, we predict the response for a given test observation using the mean of the training observations in the region to which that test observation belongs.\n>- And finally, this process may produce good predictions on the training set, but is likely to **overfit** the data, leading to poor test set performance.\n\n> $\\text{Step 2:}$ Apply **cost complexity pruning** to the large tree in order to obtain a sequence of best subtrees, as a function of $\\alpha$.\n>- One possible strategy is that we can build the tree only so long as the decrease in the $\\text{RSS}$ due to each split exceeds some (high) threshold.\n>- Therefore, a better strategy is to grow a very large tree $T_0$, and then $\\text{prune}$ it back in order to obtain a $\\text{subtree}$.\n>- To select a subtree with the lowest test error rate, we can estimate its test error using cross-validation or the validation set approach. But estimating the CV error for every possible subtree would be computationally expensive \"Cumbersome\".\n>- So, Cost $\\text{complexity pruning}$ also known as $\\text{weakest link pruning}$ gives us a way to do just this. Rather than considering every possible subtree, we consider a sequence of trees indexed by a nonnegative tuning parameter $\\alpha$.\n>- For each value of α there corresponds a subtree $T \\subset T_0$ is as small as possible such that\n$$\n\\sum_{m=1}^{|T|} \\sum_{i: x_i \\in R_m} (y_i - \\hat{y}_{Rm})^2 + \\alpha |T| \\tag{8.4}\n$$\n>- Here the tuning parameter $\\alpha$ controls a trade-off between the subtree's complexity and its fit to the training data. \n> - **Quick reminder:** (Equation $(8.4)$ is a similar $\\text{cost + penalty}$ format as regularization methods as the **lasso** $(6.7)$ from Chapter $6$, in which a similar formulation was used in order to control the complexity of a linear model.)\n>- When $\\alpha$ = 0, then the subtree $T$ will simply equal to $T_0$, because then $(8.4)$ just measures the training error \"cost\". \n>- As we start to increase $\\alpha$, branches get pruned from the tree in a nested and predictable fashion, so obtaining the whole sequence of subtrees as a function of $\\alpha$ is easy.\n\n> $\\text{Step 3:}$ We can select a value of $\\alpha$ using a **validation set** or using **cross-validation**. We then return to the full data set and obtain the subtree corresponding to $\\alpha$ as following.\n>- Use **K-fold cross-validation** to choose $\\alpha$. That is, divide the training observations into $K$ folds. For each $k = 1, \\dots ,K$:\n> - $(a)$ Repeat Steps $1$ and $2$ on all but the $k$th fold of the training data.\n> - $(b)$ Evaluate the mean squared prediction error on the data in the left-out $k$th fold, as a function of $\\alpha$. Average the results for each value of $\\alpha$, and pick $\\alpha$ to minimize the average error.\n\n> $\\text{Step 4:}$ Return the subtree from Step $2$ that corresponds to the chosen value of $\\alpha$, re-fit a regression tree on the full dataset to obtain the subtree, and use this final form for prediction.\n\n# Done!\n", "meta": {"hexsha": "83db04dbe8bed5504f481df3dd9899eae0d4f53b", "size": 84206, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/8_4_0_Tree-Based_Methods_Conceptual.ipynb", "max_stars_repo_name": "MostaAshour/ISL-in-python", "max_stars_repo_head_hexsha": "87255625066f88d5d4625d045bdc6427a4ad9193", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Notebooks/8_4_0_Tree-Based_Methods_Conceptual.ipynb", "max_issues_repo_name": "MostaAshour/ISL-in-python", "max_issues_repo_head_hexsha": "87255625066f88d5d4625d045bdc6427a4ad9193", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Notebooks/8_4_0_Tree-Based_Methods_Conceptual.ipynb", "max_forks_repo_name": "MostaAshour/ISL-in-python", "max_forks_repo_head_hexsha": "87255625066f88d5d4625d045bdc6427a4ad9193", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 233.2576177285, "max_line_length": 53140, "alphanum_fraction": 0.8889390305, "converted": true, "num_tokens": 3598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34158248603300034, "lm_q2_score": 0.3702254064929193, "lm_q1q2_score": 0.12646251474242948}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\n\n```python\n%pylab inline\n```\n\n Populating the interactive namespace from numpy and matplotlib\n\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)//2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000, step=step, return_inferencedata=False)\n```\n\n Multiprocess sampling (4 chains in 4 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n\n\n\n\n
\n \n
\n 100.00% [60000/60000 00:06<00:00 Sampling 4 chains, 0 divergences]\n
\n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9b5c40f1d6b5c7a7edca2241200d95ae41c8a8b0", "size": 298620, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "minoring/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "6b03b8810975bf27a22efcf060cde89d5786a85b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "minoring/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "6b03b8810975bf27a22efcf060cde89d5786a85b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "minoring/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "6b03b8810975bf27a22efcf060cde89d5786a85b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 241.9935170178, "max_line_length": 84320, "alphanum_fraction": 0.8954925993, "converted": true, "num_tokens": 11548, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.2628418431456957, "lm_q1q2_score": 0.1262899013303192}}
{"text": "**Francisco José Navarro-Brull**\n\n*TÉCNICAS DE CÁLCULO NUMÉRICO APLICADAS A LA FÍSICA Y A LA QUÍMICA - Máster en Ciencia de Materiales de la Universidad de Alicante*\n\n# OriginLab vs Python (comparación de gráficas)\n\nEl software [OriginLab®](http://www.originlab.com/) es uno de lo más utilizados en el mundo académico gracias a su versatilidad y potencia de cálculo. En concreto, OriginLab® tiene una serie de ventajas frente a sus *competidores* (Excel®, MATLAB®...) ya que logra unir ambos mundos permitiendo a alguien acostumbrado a la interfaz del primero realizar tareas de cálculo numérico más comunes del segundo. Pero si hay algo que verdaderamente es útil para un investigador que utiliza OriginLab®, son sus gráficas \"listas para publicar\".\n\nEn este contexto, [Python](https://www.python.org/) cuenta con magníficas librerías capaces de llevar a cabo tareas de cálculo numérico (NumPy, SciPy) así para obtener gráficas (matplotlib) de calidad equivalente o superior a OriginLab.\n\nSi has leído con detenimiento hasta aquí y te suena el software citado hasta ahora, la pregunta que te vendrá a la mente es ¿cómo un lenguaje de programación como Python va a sustituir a OrginLab® y su interfaz tipo Excel®?\n\nVeamos, Python junto a sus librerías permite a día de hoy resolver el ciclo de trabajo propio tal y como permite OriginLab®. Éstos son:\n1. Importar datos (xlrd, NumPy, csv, pandas)\n2. Procesado de datos y cálculo (SciPy, NumPy)\n3. Visualización (matplotib)\n4. Iteración pasos 2 y 3 (IPython Notebook, Spyder)\n5. Publicación de resultados (matplotib)\n\nEntonces, **¿por qué no todo el mundo está usando Python? ¿cuál es el problema?**\n\nBien, en todo este planteamiento Python *falla* en un concepto. OriginLab® no requiere conocimientos de programación para su uso más básico, Python sí.\n\nPor norma general:\n\n* Muchos científicos no tienen conocimientos de programación (o éstos son muy reducidos)\n* No tienen tiempo y quieren realizar estas tareas de la forma más rápida posible\n* Representar gráficas por comandos de texto puede ser frustrante\n\nUn fanático de Python (u otro lenguaje) te intentará convencer hablándote de las ventajas de aprender a programar, que ciertamente son muchas, pero esto te llevará tiempo (que *no* tienes) y más problemas (cuando tú lo que buscabas era una solución).
\n\n## \"Use the right tool\"\n\nSi te sientes cómodo utilizando OriginLab® y no le encuentras limitaciones, sigue utilizándolo y amortiza los 850 o 1800 dólares que vale su licencia para uso académico o profesional.\n\nSi por el contrario, quieres (y dispones de tiempo para ello):\n* Automatizar el importado y procesado de datos\n* Tener a tu alcance algoritmos avanzados (y gratuitos) de estadística, machine learning, inteligencia artificial, computer vision...\n* Ahorrar en licencias y poder usar este software en la empresa a la que vayas\n* Aprender a programar en uno de los lenguajes más versátiles que existen\n* Hacer tu investigación reproducible añadiendo a tu paper no sólo la información, si no además las herramientas poder reutilizar tu trabajo y ganar más impacto\n* Obtener gráficas para tus artículos de calidad igual o superior a Origin\n\n¡Eres bienvenido al mundo de Python!\n\n## ¿De qué va este Notebook?\n\nComo prueba de concepto, se utilizará IPython Notebook para llevar a cabo un proceso de reproducción de muchas de las gráficas que OriginLab® publicita. Puedes dar un vistazo a la [Galería de OriginLab®](http://www.originlab.com/www/products/graphgallery.aspx) y [Galería de matplotib](http://matplotlib.org/gallery.html) para ver lo similares que pueden llegar a ser.\n\nIPython Notebook un formato y solución elegante que ademas de código puede contener texto, fórmulas mediante $\\LaTeX$, vídeos, imágenes y gráficas.\n\n
Nota: La mejor manera de trabajar con matplotlib es buscar en su [galería](http://matplotlib.org/gallery.html) una gráfica similar al resultado que queramos conseguir y utilizar dicho código como guía o plantilla de trabajo
\n\n## ¿De qué _NO_ va este Notebook?\n\nPese a que se comentarán brevemente ciertas líneas de código, este notebook no pretende ser un tutorial de matplotlib y/o Python. Para una introducción a los mismos te recomendamos este [Curso online (gratuito) de introducción a Python para científicos e ingenieros](http://cacheme.org/curso-online-python-cientifico-ingenieros/) por [@Pybonacci](http://pybonacci.wordpress.com) y organizado por [CAChemE.org](http://cacheme.org).\n\nPor cierto, también puedes echarle un vistazo a [Avoplot](https://www.youtube.com/watch?v=_Bm8M9IwuFk), un proyecto muy interesante que pretende simiplificar la vida a muchos científicos pero que de momento se encuentra en fase de desarrollo.\n\n## Librerías gráficas en Python:\n\nLos siguientes ejemplos harán uso de matplotlib y ajustarán el estilo de las gráficas para hacerlas similares las de OriginLab®. Matplotlib puede parecer viejo, estático y tener una configuración por defecto cutre. Sin embargo, su uso es muy, muy extenso y ha demostrado ser una librería a prueba de todo. Tal y como mencionaba [@Pybonacci](http://twitter.com/ptbonacci), es válido para el 99% de las personas. El 1% restante tiene varias alternativas que elegir. Muchas de ellas se basan matplotlib, lo que demuestra su robustez, como [seaborn](http://www.stanford.edu/~mwaskom/software/seaborn/), [vincent](http://vincent.readthedocs.org/en/latest/), [ggplot-py](http://blog.yhathq.com/posts/ggplot-for-python.html), [prettyplot](http://olgabot.github.io/prettyplotlib/), [plot.ly](https://plot.ly/), [bearcart](https://github.com/wrobstory/bearcart) o una de las más recientes e interesantes [mpld3](http://mpld3.github.io/). Por otro lado existen alternativas que han empezado un motor gráfico de Python desde cero cómo por ejemplo [Bokeh](http://bokeh.pydata.org/).\n\nEn cualquier caso matplotlib otorga las siguientes funcionalidades.\n\n* API: Tipo MATLAB (por estados, tersa, menos poderosa) u orientada a objetos (sin estados, verbosa, más poderosa)\n* Abstracción: Básicamente un potente modelo interno de objetos SVG (vectoriales)\n* Gráficos de salida:\n * Gráficos estáticos finales (backends) de los cuales puedas necesitar: pdf, png, svg, eps, ps, pgf, jpeg...\n * Así como interfaces gráficas (GUI backends): Tk, Agg, OSX, GTK, Qt4, WebAgg...\n \nPara aprender más sobre matplotib es recomendable leer [Python in the browser age](http://nbviewer.ipython.org/urls/raw.githubusercontent.com/jakevdp/OpenVisConf2014/master/Index.ipynb) por Jake VanderPlas (fuente original de lo descrito en este último párrafo).\n\n# Comparación de capacidades gráficas (Origin vs Python)\n\nEn primer lugar, queremos que las gráficas aparezcan en este mismo notebook por lo que damos la siguiente instrucción:\n\n\n```python\n%matplotlib inline\n```\n\nActo seguido importamos las librerías necesarias para la generación y representación los resultados:\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nEn caso de trabajar con Python 2.7:\n\n\n```python\nfrom __future__ import division\n```\n\n### Potencia de matplotlib: Resultados combinados con $\\LaTeX$\n\nAntes de empezar veamos un ejemplo de la capacidad de matplotlib para generar figuras \"listas para publicar\" y su magnífica inegración con $\\LaTeX$. Además de representar valores numéricos, matplotlib permite la añadir notas y texto en este formato. Un ejemplo de esta funcionalidad es el siguiente:\n\n\n```python\n# Los comentarios en Python se escriben empezando con una almohadilla\n# estas líneas serán ignoradas en la ejecución \n\n\n# Creamos la función que queremos representar (e integrar)\ndef func(x):\n return (x - 3) * (x - 5) * (x - 7) + 85\n\n# Especificamos los límtes de integración\na, b = 2, 9 \n\n# Crea un vector con valores de 0 a 10\nx = np.linspace(0, 10)\n\n# Obtenemos los valores de y correspondientes\ny = func(x)\n\n# Utilizamos matplotlib (este formato es orientado a clases)\n# matplotlib también puede usarse tipo MATLAB(R)\nfig, ax = plt.subplots()\n\n# Dibuja con una línea roja de espesor determinado los resultados\nplt.plot(x, y, 'r', linewidth=2)\n\n# Establece el límite inferior del eje y\nplt.ylim(ymin=0)\n\n# Crea la región sombreada que representará la integral\nix = np.linspace(a, b)\niy = func(ix)\n\n# Coordenadas de los puntos del polígono de la integral a representar\nverts = [(a, 0)] + list(zip(ix, iy)) + [(b, 0)]\n\n# Carga la función Polygon de la librería\nfrom matplotlib.patches import Polygon\n\n# Representa dicho polígono cierto 90 y 50% de transparencia para el relleno y borde.\npoly = Polygon(verts, facecolor='0.9', edgecolor='0.5')\nax.add_patch(poly)\n\n# Añade texto en latex con la siguiente instruccion\n# plt.text(coordenada_x, coordenada_y, texto, opciones)\nplt.text(0.5 * (a + b), 30, r\"$\\int_a^b f(x)\\mathrm{d}x$\",\n horizontalalignment='center', fontsize=20)\n\n# Añade texto con posición relativa para indicar los ejes\nplt.figtext(0.9, 0.05, '$x$')\nplt.figtext(0.1, 0.9, '$y$')\n\n# Ocutlamos los bordes superior y derecho del cuadro de la gráfica\nax.spines['right'].set_visible(False)\nax.spines['top'].set_visible(False)\n\n# Añade marcas en el eje x con los límites de integración\n# Coordenadas\nax.set_xticks((a, b))\n# Texto\nax.set_xticklabels(('$a$', '$b$'))\n\n# Establece marcas sólo en el eje x inferior\nax.xaxis.set_ticks_position('bottom')\n\n# Elimina marcas del eje y\nax.set_yticks([])\n\n# Muestra figura\nplt.show()\n\n# Guarda figura en png o pdf\n# Más formatosy y/o opciones mirar en la documentación\n# http://matplotlib.org/faq/howto_faq.html#save-multiple-plots-to-one-pdf-file\n\n# Dado que llamamos a la figura \"fig\" cuando la creamos,\n# llamamos al método .savefig\n\n#fig.savefig(r'figuras/mi_figura.pdf')\n#fig.savefig(r'figuras/mi_figura.png')\n```\n\n### Representación de errores\n\nA pesar de que Excel® permite representar errores en los gráficos, esta es una funcionalidad importante. Veamos como podemos hacer esto con matplotib.\n\n\n```python\nn_grupos = 11\n\nvalores = (2.5, 7.5, 20, 26, 16, 11, 22.5, 24, 29, 25, 20)\nerrores = (0.5, 1, 2, 2, 1.5, 1, 2, 2, 2, 2, 2)\n\nfig, ax = plt.subplots()\n\nax.yaxis.grid()\n\nindex = np.arange(n_grupos)\nancho_banda = 0.8\n\nopacity = 0.6\nerror_config = {'ecolor': '0.3'}\n\ndistancia_inicio = 0.5\n\ncoordenadas_x_barras = index+distancia_inicio\n\nrects1 = plt.bar(coordenadas_x_barras, valores, ancho_banda,\n alpha=opacity,\n color='orange',\n yerr=errores,\n error_kw=error_config,\n )\n\nplt.xlabel('Bin')\nplt.ylabel('Count')\n\netiquetas_eje_x = ('7-8', '9-10', '11-12', '13-14', '15-16',\n '17-18', '19-20', '21-22', '23-24', '25-26', '27-28')\n\ncoordenadas_etiquetas_x = index + ancho_banda/2 + distancia_inicio\n\nplt.xticks(coordenadas_etiquetas_x, etiquetas_eje_x)\nplt.tight_layout()\n\n# Opcional si queremos salvar las figuras como archivos\n#fig.savefig(r'figuras/barras_errores.pdf')\n#fig.savefig(r'figuras/barras_errores.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries_new/Error_Bar_Scatter_and_Column_Plot.gif).\n\n\n\n### Diagramas de cajas (Whiskey)\n\nVeamos algo más interesante, realizar [diagramas de cajas y bigotes](http://es.wikipedia.org/wiki/Diagrama_de_caja) con Excel® ya no es tan sencillo. Sin embargo en matplotlib:\n\n\n```python\ndef fakeBootStrapper(n):\n '''\n Devuelve una mediana arbitraria e intervalos de confianza\n en una tupla\n '''\n if n == 1:\n med = 0.1\n CI = (-0.25, 0.25)\n else:\n med = 0.2\n CI = (-0.35, 0.50)\n\n return med, CI\n\n\n# Fija una semilla para el random\nnp.random.seed(2)\ninc = 0.1\ne1 = np.random.normal(0, 1, size=(500,))\ne2 = np.random.normal(0, 1, size=(500,))\ne3 = np.random.normal(0, 1 + inc, size=(500,))\ne4 = np.random.normal(0, 1 + 2*inc, size=(500,))\n\ntratamientos = [e1,e2,e3,e4]\nmed1, CI1 = fakeBootStrapper(1)\nmed2, CI2 = fakeBootStrapper(2)\nmedianas = [None, None, med1, med2]\nconf_intervalos = [None, None, CI1, CI2]\n\nfig, ax = plt.subplots()\n\n# Posiciones de las cajas\npos = np.array(range(len(tratamientos)))+1\n\n# Representa el diagrama\nbp = ax.boxplot(tratamientos, sym='k+', positions=pos,\n notch=1, bootstrap=5000,\n usermedians=medianas,\n conf_intervals=conf_intervalos)\n\n# Etiquetas para los ejes\nax.set_xlabel('Tratamiento')\nax.set_ylabel('Respuesta')\n\n# Tipo de diagrama de cajas (Whisker)\nplt.setp(bp['whiskers'], color='k', linestyle='-' )\nplt.setp(bp['fliers'], markersize=5.0)\n\n# Opcional si queremos salvar las figuras como archivos\n# fig.savefig(r'figuras/diagra-cajas.pdf')\n# fig.savefig(r'figuras/diagra-cajas.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries_new/Box_Width_by_Variable.png).\n\n\n\n### Matriz de dispersión (Scatter Matrix)\n\n\n```python\n# La forma más sencilla de realizar esta visualización es\n# mediante la librería pandas que permite trabajar de forma similar a R\n\nimport pandas as pd\n\n# Lee los datos (deben de estar en la carpeta de este Notebook)\n# http://en.wikipedia.org/wiki/Iris_flower_data_set\n\niris = pd.read_csv(\"data/iris.csv\")\n\n# Establece el dataframe\ndf = pd.DataFrame(iris, columns=['Longitudo-sepalo', 'Anchura-sepalo',\n 'Longitud-petalo', 'Anchura-petalo'])\n\n# Calcula y representa resultados\npd.scatter_matrix(df, alpha=0.6, figsize=(10,10))\n\n# Opcional si queremos salvar las figuras como archivos\n#plt.savefig(r'figuras/matriz-dispersion.pdf')\n#plt.savefig(r'figuras/matriz-dispersion.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries/Scatter_Matrix_1127.png).\n\n\n\n### Diagramas con coordenadas polares:\n\n\n```python\nN = 50\nradio = 2 * np.random.rand(N)\ntheta = 2 * np.pi * np.random.rand(N)\narea = 75 * radio**2 * np.random.rand(N)\ncolores = np.random.rand(N)\n\n# Crea una figura con coordenadas polares\nax = plt.subplot(111, polar=True)\n\n# Representa una diagrama de dispersión\nc = plt.scatter(theta, radio, c=colores,\n s=area, alpha=0.70)\n\n# Opcional si queremos salvar las figuras como archivos\n#plt.savefig(r'figuras/coordenadas-polares.pdf')\n#plt.savefig(r'figuras/coordenadas-polares.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin:\n\n\n\n### Diagramas de contorno:\n\nOtro tipo de gráfico que Excel® presenta limtaciones son los diagramas de contorno. Veamos cómo hacerlo con matplotlib:\n\n\n```python\n# Función que queremos representar\ndef g(x, y):\n return -(np.cos(x) * np.sin(y))**3\n\n# Genera dos vectores para la malla\n# valor numérico alto para ver resultados de la curva suaves\nx = np.linspace(-2, 4, 1000)\ny = np.linspace(-2, 3, 1000)\n\n# Creamos la malla \nxx, yy = np.meshgrid(x, y)\n\n# Calculamos los valores de la función para cada punto de la malla\nzz = g(xx, yy)\n\n# Ajusta el tamaño de la figura con figsize\nfig, axes = plt.subplots(figsize=(10, 8))\n\n# Asigna la salida a la variable cs para luego crear el colorbar\ncs = axes.contourf(xx, yy, zz, np.linspace(-1, 2, 100), cmap=plt.cm.BrBG)\n\n# Con `colors='k'` dibujamos todas las líneas negras\n# Asigna la salida a la variable cs2 para crear las etiquetas\ncs2 = axes.contour(xx, yy, zz, np.linspace(-1, 2, 9), colors='k')\n\n# Crea las etiquetas sobre las líneas\naxes.clabel(cs2)\n\n# Crea la barra de colores (nótese que pertenece a fig)\nfig.colorbar(cs)\n\n# Ponemos las etiquetas de los ejes\naxes.set_xlabel(\"Eje x\")\naxes.set_ylabel(\"Eje y\")\naxes.set_title(u\"Función representada: $g(x, y) = - (\\cos{x} \\, \\sin{y})^3$\",fontsize=20)\n\n\n# Opcional si queremos salvar las figuras en archivos\n#fig.savefig(r'figuras/diagrama-contorno.pdf')\n#fig.savefig(r'figuras/diagrama-contorno.png',dpi=150)\n\n# Muestra figura\nplt.show()\n\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries_new/Overlay_Contour_Plot.png).\n\n\n\n## Gráficas en 3D\n\nUna de las cosas más llamativas que publicita OriginLab® es el uso de su herramienta para graficar resultados en 3D. Ciertamente, Excel® dispone de pocas herramientas en ese aspecto y MATLAB® tiene el mismo problema que Python (hay que aprender a programar) con el añadido del coste de licencia extra. Por ello la solución más cómoda es usar OriginLab®. No te ahorras la licencia pero te evitas tener que aprender programar.\n\nExiste una regla no escrita que dice algo así: **_\"si la única forma de representar tus resultados es con una gráfica 3D, es que algo estás haciendo mal\"_**\n\nSin ánimo de ser tan radicales, vivimos en un mundo 2D. El papel o pantalla donde se verán tus resultados son en 2D y por ello es mejor evitar representar resultados mediante gráficas 3D. No obstante, para exploración y visualización de resultados interactiva, son una herramienta muy potente. Cabe destacar que matplotlib empezó a dar soporte a figuras en 3D recientemente. Si se requieren visualizaciones más complejas es recomendable usar [Mayavi](http://docs.enthought.com/mayavi/mayavi/auto/examples.html)\n\nVeamos como hacer esto con matplotlib:\n\n\n```python\n# Cargamos la librería 3D de matplotlib\nfrom mpl_toolkits.mplot3d import axes3d\n\n# Acceso rápido a los mapas de colores (colormap)\nfrom matplotlib import cm\n```\n\n## Superficie en 3D\n\nEmpecemos con algo sencillo. Vamos a representar la superficie de un parboloide.\n\n\n```python\n# Crea los vectores x e y\nx = np.arange(-2, 2, 0.05)\ny = np.arange(-2, 2, 0.05)\n\n# Genera el mallado 2D\nX, Y = np.meshgrid(x,y)\n\n# Calcula Z: Paraboloide\nZ = (X)**2-(Y)**2\n\n# Tamaño de figura\nfig = plt.figure(figsize=(8,8))\n\n# Proyección de la figura en 3D\nax = fig.gca(projection='3d')\n\n# Dibuja los resultados\nax.plot_surface(X, Y, Z, rstride=1, cstride=1, cmap=cm.jet,\n linewidth=0, antialiased=False)\n\n# Texto de las etiquetas\nax.set_xlabel(\"Eje X\")\nax.set_ylabel(\"Eje Y\")\nax.set_zlabel(\"Eje Z\")\nax.set_title(\"Paraboloide\", fontsize=16)\n\n# Opcional si queremos salvar las figuras en archivos\n#fig.savefig(r'figuras/superficie-3D.pdf')\n#fig.savefig(r'figuras/superficie-3D.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries_new/3d_surface_from_virtual_matrix_opengl.png).\n\n\n\n### Superficies 3D combinadas con diagramas de contorno\n\n\n```python\nfig = plt.figure(figsize=(8,6))\n\nax = fig.gca(projection='3d')\n\n# Carga datos de para test\nX, Y, Z = axes3d.get_test_data(0.01)\n\nsurf = ax.plot_surface(X, Y, Z, rstride=10, cstride=10, alpha=1,\n cmap=cm.jet, linewidth=0.1)\n\n# Proyección en la base\ncset = ax.contourf(X, Y, Z, 25, zdir='z', offset=-100, cmap=cm.jet, )\n\n# Proyección de líneas en el lateral\ncset = ax.contour(X, Y, Z, zdir='y', offset=-30, cmap=cm.jet)\n\n# Añade barra de color con valores de Z\nfig.colorbar(surf, shrink=0.5, aspect=10)\n\n# Configuración de ejes y etiquetas\nax.set_xlabel('X')\nax.set_xlim(-30, 30)\nax.set_ylabel('Y')\nax.set_ylim(-30, 30)\nax.set_zlabel('Z')\nax.set_zlim(-100, 100)\n\nax.set_title(\"Generado con matplotlib\", fontsize=16)\n\n# Opcional si queremos salvar las figuras en archivos\n#fig.savefig(r'figuras/superficie-3D-combinado.pdf')\n#fig.savefig(r'figuras/superficie-3D-combinado.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries_new/3D_Surface_Plot.png).\n\n\n\n### Cascada 3D\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib.collections import PolyCollection\nfrom matplotlib.colors import colorConverter\nimport matplotlib.pyplot as plt\nimport numpy as np\n\n# Para poder crear las señales usaremos una funcion de Gauss\n# y le añadiremos ruido blanco\n\ndef gauss_ruido(x,posicion,desviacion):\n ''' Genera una curva de Gauss con ruido blanco\n con la posicion y desviacion estándar de entrada'''\n y = np.exp( -(x-posicion)**2) / (2*np.sqrt(desviacion))\n ruido = 0.01* np.random.randn(len(x))\n senyal = y + ruido\n return senyal\n\n\nfig = plt.figure(figsize=(10,6))\nax = fig.gca(projection='3d')\n\ncc = lambda arg: colorConverter.to_rgba(arg, alpha=0.6)\n\n\n\nposicion= [50, 60, 70, 80]\n\n\nverts = []\nfor pos in posicion:\n x = np.linspace(0,150,100)\n \n y = np.abs(gauss_ruido(x,pos,5))\n \n y[0], y[-1] = 0, 0\n verts.append(list(zip(x, y)))\n\n\npoly = PolyCollection(verts, facecolors = [cc('r'), cc('g'),\n cc('b'), cc('y')])\npoly.set_alpha(0.7)\n\n# Posicion de z\nzs = [0.1, 0.25, 0.50, 0.75]\n\n# Dibuja los poligonos generados seleccionado\n# la señal y como eje vertical\nax.add_collection3d(poly, zs=zs, zdir='y')\n\nax.set_xlabel('Espectro')\nax.set_xlim3d(0, 150)\nax.set_ylabel('t muestra / s')\nax.set_ylim3d(0, 1)\nax.set_zlabel(u'C / mg/ml')\nax.set_zlim3d(0, 0.25)\n\n# Ángulo\nax.view_init(20,280)\n\n# Opcional si queremos salvar las figuras en archivos\n#fig.savefig(r'figuras/cascada-3D.pdf')\n#fig.savefig(r'figuras/cascada-3D.png',dpi=150)\n\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries/3D_waterfall_w_4plane_2.png).\n\n\n\n\n### Diagramas de dispersión en 3D:\n\nPor simplicidad, el siguiente ejemplo creará los datos con funciones de números aleatorios. No obstante, se podría hacer el agrupamiento de datos [Iris](http://en.wikipedia.org/wiki/Iris_flower_data_set) con Python y [scikit-learn](http://claudiovz.github.io/scipy-lecture-notes-ES/packages/scikit-learn/index.html#k-means-clustering).\n\n\n```python\nfig = plt.figure(figsize=(10,8))\nax = fig.gca(projection='3d')\n\n# Genereamos los puntos con una distribución estándar normal de (n_puntos, dimensiones) \n# y su repreesntación 3d junto a la proyección en el plano x-y\nz_offset = 3\n\ncoordenadas_clase1 = np.array([2,1,5])\nclase1 = 0.15 * np.random.standard_normal((50,3)) + coordenadas_clase1\nax.plot(clase1[:,0],clase1[:,1],clase1[:,2],'ko', alpha=0.6, label='Setosa')\n\nax.plot(clase1[:,0], clase1[:,1], np.zeros_like(clase1[:,2])+z_offset, 'ko')\n\ncoordenadas_clase2 = np.array([3.5,2.5,6])\nclase2 = 0.3 * np.random.standard_normal((50,3)) + coordenadas_clase2\nax.plot(clase2[:,0],clase2[:,1],clase2[:,2],'ro', alpha=0.6, label='Versicolor')\nax.plot(clase2[:,0], clase2[:,1], np.zeros_like(clase2[:,2])+z_offset, 'ro')\n\ncoordenadas_clase3 = np.array([6,3,7])\nclase3 = 0.4 * np.random.standard_normal((50,3)) + coordenadas_clase3\nax.plot(clase3[:,0],clase3[:,1],clase3[:,2],'go', alpha=0.6, label='Virginica')\nax.plot(clase3[:,0], clase3[:,1], np.zeros_like(clase3[:,2])+z_offset, 'go')\n\n# Generamos las esferas\n\nu1 = np.linspace(0, 2 * np.pi, 100)\nv1 = np.linspace(0, np.pi, 100)\n\nx_esfera_1 = 1 * np.outer(np.cos(u1), np.sin(v1)) + coordenadas_clase1[0]\ny_esfera_1 = 0.5 * np.outer(np.sin(u1), np.sin(v1)) + coordenadas_clase1[1]\nz_esfera_1 = 1.5 * np.outer(np.ones(np.size(u1)), np.cos(v1)) + coordenadas_clase1[2]\nax.plot_surface(x_esfera_1, y_esfera_1, z_esfera_1,\n rstride=10, cstride=10, linewidth=0.1, color='b', alpha=0.1)\n\nu2 = np.linspace(0, 2 * np.pi, 100)\nv2 = np.linspace(0, np.pi, 100)\n\nx_esfera_2 = 1.5 * np.outer(np.cos(u2), np.sin(v2)) + coordenadas_clase2[0]\ny_esfera_2 = 1 * np.outer(np.sin(u2), np.sin(v2)) + coordenadas_clase2[1]\nz_esfera_2 = 1.8 * np.outer(np.ones(np.size(u2)), np.cos(v2)) + coordenadas_clase2[2]\nax.plot_surface(x_esfera_2, y_esfera_2, z_esfera_2,\n rstride=10, cstride=10, linewidth=0.1, color='r', alpha=0.1)\n\nu3 = np.linspace(0, 2 * np.pi, 100)\nv3 = np.linspace(0, np.pi, 100)\n\nx_esfera_3 = 1.5 * np.outer(np.cos(u3), np.sin(v3)) + coordenadas_clase3[0]\ny_esfera_3 = 1 * np.outer(np.sin(u3), np.sin(v3)) + coordenadas_clase3[1]\nz_esfera_3 = 2 * np.outer(np.ones(np.size(u3)), np.cos(v3)) + coordenadas_clase3[2]\nax.plot_surface(x_esfera_3, y_esfera_3, z_esfera_3,\n rstride=10, cstride=10, linewidth=0.1, color='g', alpha=0.1)\n\n# Establcemos límites en los ejes y los etiquetamos\nax.set_xlim3d(0, 8)\nax.set_ylim3d(0, 4)\nax.set_zlim3d(z_offset, 9)\n\nax.set_xlabel(u'Longitud del pétalo (cm)')\nax.set_ylabel(u'Anchura del pétalo (cm)')\nax.set_zlabel(u'Longitud del sépalo (cm)')\n\n# Muestra leyenda\nax.legend()\n\n# Opcional si queremos salvar las figuras en archivos\n#fig.savefig(r'figuras/dispersion-3D.pdf')\n#fig.savefig(r'figuras/dispersion-3D.png',dpi=150)\n\nplt.show()\n```\n\nResultado reproducido con Origin [(ver online)](http://cloud.originlab.com/www/resources/graph_gallery/images_galleries_new/3D_Scatter_combined_with_Parametric_Surfaces.png).\n\n\n\n## Un paso más allá\n\nComo se ha comentado, Python dispone de diversas librerías. Una de las más interesante es [SymPy](http://sympy.org/en/index.html) que proporciona poderosas funciones sistemas de álgebra computacional (CAS, computer algebraic system). El siguiente código se puede ejecutar sin necesidad de las anteriores celdas ya que es independiente. El propósito es una demostración de la interactivdad con los nuevos [widgets de IPython Notebook 2.0](http://nbviewer.ipython.org/github/ipython/ipython/blob/2.x/examples/Interactive%20Widgets/Index.ipynb).\n\n\n```python\n# Cargamos widgets interactivos de IPython Notebook\n\nfrom IPython.html.widgets import interact\nfrom IPython.display import display\n```\n\n\n```python\n# Cargamos las partes de SymPy que vamos a utilizar\n\nfrom sympy import Symbol, Eq, factor, init_printing\ninit_printing(use_latex='mathjax')\n```\n\n\n```python\n# Creamos la variable simbólica x\nx = Symbol('x')\n```\n\n\n```python\n# Creamos la función de factorización para el ejemplo\ndef factorit(n):\n display(Eq(x**n-1, factor(x**n-1)))\n```\n\nCuando ejectuemos la función, nos devolverá un resultado en $\\LaTeX$\n\n\n```python\nfactorit(12)\n```\n\n\n$$x^{12} - 1 = \\left(x - 1\\right) \\left(x + 1\\right) \\left(x^{2} + 1\\right) \\left(x^{2} - x + 1\\right) \\left(x^{2} + x + 1\\right) \\left(x^{4} - x^{2} + 1\\right)$$\n\n\n\n```python\ninteract(factorit, n=(2,20));\n```\n\n\n$$x^{11} - 1 = \\left(x - 1\\right) \\left(x^{10} + x^{9} + x^{8} + x^{7} + x^{6} + x^{5} + x^{4} + x^{3} + x^{2} + x + 1\\right)$$\n\n\nEs hora de hacer algo más interesante. Hagamos una expansión por serie de Taylor de $\\frac{sin{x}}{x}$\n\n\n```python\nfrom sympy import Symbol, sin, series, exp\nx = Symbol('x')\n\necuacion_ejemplo = sin(x)/x\norden = 5\n\nseries(ecuacion_ejemplo, x, n=orden)\n\n```\n\n\n\n\n$$1 - \\frac{x^{2}}{6} + \\frac{x^{4}}{120} + \\mathcal{O}\\left(x^{5}\\right)$$\n\n\n\nVamos a representar los resultados de forma interactiva\n\n\n```python\nfrom sympy.plotting import plot\n\n# Representa las figuras en línea con el documento (no en una ventana emergente)\n%matplotlib inline\n```\n\n\n```python\ndef taylor_graf(n):\n \n e = exp(1)\n ecuacion = e**x\n \n #calculamos la expansion elimnando el termino del error\n ecuacion_aprox = series(ecuacion, x, n=n+1).removeO()\n \n p1 = plot(ecuacion, (x, -3, 3), show=False, line_color='b', label='ecuacion')\n p2 = plot(ecuacion_aprox, (x, -3, 3), show=False, line_color='r', label='aprox')\n \n # Haz la segunda función parte de la primera\n p1.extend(p2)\n # Nota: Este código se debe a que representar dos funciones juntas con diferentes colores \n # aun no está implmentado\n # http://stackoverflow.com/questions/21429866/change-color-implicit-plot-sympy\n \n p1.show()\n```\n\nFunción exponencial $e^x$ (en azul) y la suma de los primeros n+1 términos\n\n\nde su serie de Taylor en torno a cero (en rojo).\n\n\n```python\ninteract(taylor_graf, n=(0,10));\n```\n\nSi estás viendo este IPython Notebook offline, este es el resultado:\n\n\nPor último, SymPy también representa expresiones matemáticas en 3D:\n\n\n```python\nfrom sympy import symbols\nfrom sympy.plotting import plot3d\n\nx, y = symbols('x y')\n```\n\n\n```python\nplot3d(abs(x*y), (x, -5, 5), (y, -5, 5))\n```\n\nEste IPython Notebook puede imprimirse en PDF generando (previamente) un archivo \".tex\" $\\LaTeX$ mediante [pandoc](http://johnmacfarlane.net/pandoc/). Por ejemplo para obtener el archivo basta con ejecutar en la línea de comandos el siguiente código\n\n`ipython nbconvert --to latex originlab-python.ipynb`\n\nSi se desea obtener más información, consultar [documentación](http://ipython.org/ipython-doc/stable/notebook/nbconvert.html).\n\n\n", "meta": {"hexsha": "dbba2e00dd538232199069cd95a743f4aa47ce54", "size": 1022184, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "originlab-python.ipynb", "max_stars_repo_name": "franktoffel/origin", "max_stars_repo_head_hexsha": "a7fae554aab79678769500ff26346c77119a5997", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2017-02-21T22:30:21.000Z", "max_stars_repo_stars_event_max_datetime": "2017-02-21T22:30:21.000Z", "max_issues_repo_path": "originlab-python.ipynb", "max_issues_repo_name": "franktoffel/origin", "max_issues_repo_head_hexsha": "a7fae554aab79678769500ff26346c77119a5997", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "originlab-python.ipynb", "max_forks_repo_name": "franktoffel/origin", "max_forks_repo_head_hexsha": "a7fae554aab79678769500ff26346c77119a5997", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 82.2021712907, "max_line_length": 1081, "alphanum_fraction": 0.8252203126, "converted": true, "num_tokens": 8603, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489883132727684, "lm_q2_score": 0.30404168127272885, "lm_q1q2_score": 0.1261465382348356}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 1000]\np_true = 0.6\ndata = stats.bernoulli.rvs(p_true, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(p_true, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of p = p_true (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\n Applied log-transform to lambda_1 and added transformed lambda_1_log to model.\n Applied log-transform to lambda_2 and added transformed lambda_2_log to model.\n\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", mu=lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(draws=10000, tune=5000,step=step)\n```\n\n [-----------------100%-----------------] 10000 of 10000 complete in 3.9 sec\n\n\n```python\ntrace['lambda_1'].size\n```\n\n\n\n\n 10000\n\n\n\n\n```python\nlambda_1_samples = trace['lambda_1']\nlambda_2_samples = trace['lambda_2']\ntau_samples = trace['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\nprint('lambda 1 mean: {}'.format(lambda_1_samples.mean()))\nprint('lambda_2_mean: {}'.format(lambda_2_samples.mean()))\n```\n\n lambda 1 mean: 17.747493644\n lambda_2_mean: 22.6835346022\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\nwith model:\n increase = pm.Deterministic('perc_increase', (lambda_2 - lambda_1) / lambda_1)\n \nwith model:\n step = pm.Metropolis()\n trace = pm.sample(draws=50000, tune=5000,step=step)\n```\n\n [-----------------100%-----------------] 50000 of 50000 complete in 20.6 sec\n\n\n```python\nprint('percent increase: {}'.format(trace['perc_increase'].mean() * 100))\n```\n\n percent increase: 27.8453634501\n\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\nless_than_45 = tau_samples < 45\nprint('Expected value of lambda_1 prior to day 45: {}'.format(lambda_1_samples[less_than_45].mean()))\n\n```\n\n Expected value of lambda_1 prior to day 45: 17.7647471828\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55
\n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7145540b37150f8aedb350dd7a798bd64f230a97", "size": 313042, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_annotated_and_altered.ipynb", "max_stars_repo_name": "tblazina/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "0ae511a74d934fb304de0e15b77882824ac40552", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_annotated_and_altered.ipynb", "max_issues_repo_name": "tblazina/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "0ae511a74d934fb304de0e15b77882824ac40552", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_annotated_and_altered.ipynb", "max_forks_repo_name": "tblazina/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "0ae511a74d934fb304de0e15b77882824ac40552", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 273.6381118881, "max_line_length": 91340, "alphanum_fraction": 0.8928737997, "converted": true, "num_tokens": 11416, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4225046493573919, "lm_q2_score": 0.29746993014852224, "lm_q1q2_score": 0.12568242853176925}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n`Original content created by Cam Davidson-Pilon`\n\n`Ported to Python 3 and PyMC3 by Max Margenot (@clean_utensils) and Thomas Wiecki (@twiecki) at Quantopian (@quantopian)`\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: Pyro\n-----\n\n\n\n```python\nimport torch\nimport pyro\nimport pyro.distributions as dist\n```\n\n\n```python\ncount_data = torch.Tensor(count_data)\n```\n\n\n```python\ndef model(data):\n alpha = (1. / data.mean())\n lambda1 = pyro.sample(\"lambda_1\", dist.Exponential(rate=alpha))\n lambda2 = pyro.sample(\"lambda_2\", dist.Exponential(rate=alpha))\n\n tau = pyro.sample(\"tau\", dist.Uniform(0, 1))\n lambda1_size = (tau * data.size(0) + 1).long()\n lambda2_size = data.size(0) - lambda1_size\n lambda_ = torch.cat([lambda1.expand((lambda1_size,)),\n lambda2.expand((lambda2_size,))])\n \n with pyro.plate(\"data\", data.size(0)):\n pyro.sample(\"obs\", dist.Poisson(lambda_), obs=data)\n```\n\n\n```python\n# hmc_kernel = pyro.infer.HMC(model, jit_compile=True, ignore_jit_warnings=True) # Really Slow\nnuts_kernel = pyro.infer.NUTS(model, jit_compile=True, ignore_jit_warnings=True) # Slow move to numpyro\nposterior = pyro.infer.MCMC(nuts_kernel, num_samples=1000, warmup_steps=50) # 10000, 5000 too slow\nposterior.run(count_data)\n```\n\n Sample: 100%|██████████| 1050/1050 [01:05, 16.06it/s, step size=2.76e-02, acc. prob=0.464]\n\n\n\n```python\nlambda_1_samples = posterior.get_samples()['lambda_1']\nlambda_2_samples = posterior.get_samples()['lambda_2']\ntau_samples = posterior.get_samples()['tau']\n```\n\n\n```python\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\ntau_samples = np.array((tau_samples * count_data.size(0) + 1), dtype=np.int32)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n#type your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n#type your code here.\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC3 part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n#type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Salvatier, J, Wiecki TV, and Fonnesbeck C. (2016) Probabilistic programming in Python using PyMC3. *PeerJ Computer Science* 2:e55 \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "855d5d14788978415cc88a4bbeb74806b0852793", "size": 288428, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_Pyro.ipynb", "max_stars_repo_name": "davinnovation/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "7280687a4cadb2d273a41f037aeb8d4619cc160a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_Pyro.ipynb", "max_issues_repo_name": "davinnovation/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "7280687a4cadb2d273a41f037aeb8d4619cc160a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_Pyro.ipynb", "max_forks_repo_name": "davinnovation/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "7280687a4cadb2d273a41f037aeb8d4619cc160a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 277.8689788054, "max_line_length": 84324, "alphanum_fraction": 0.9005228341, "converted": true, "num_tokens": 10783, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43782351378493656, "lm_q2_score": 0.28457600421652673, "lm_q1q2_score": 0.12459406610495666}}
{"text": "Osnabrück University - Machine Learning (Summer Term 2016) - Prof. Dr.-Ing. G. Heidemann, Ulf Krumnack\n\n# Exercise Sheet 03: Basics of Data Mining\n\n## Introduction\n\nThis week's sheet should be solved and handed in before the end of **Sunday, April 29, 2018**. If you need help (and Google and other resources were not enough), feel free to contact your groups designated tutor or whomever of us you run into first. Please upload your results to your group's studip folder.\n\nThere are a lot of implementations with fewer theory questions on this sheet, but don't worry: To be able to implement most of the code, you have to understand the theory.\n\nThis week's assignments make use of two packages: `numpy` and `matplotlib`. We already expected you to install those as part of sheet 1. If you did not do so, go back to those instructions or just run the following command in the `terminal`/`cmd.exe` to do so. This will also upgrade your current installation.\n\n conda install jupyter numpy matplotlib\n\nOne note about `matplotlib`: If you run code which contains a plot like the cell below, it can sometimes take a while to execute the code and show the results. During that process the invocation count will be shown as a little Asterisk (\\*) like this:\n\n In [*]:\n\nJust be patient for a few seconds. The following cell tests if `numpy` and `matplotlib` are installed and work:\n\n\n```python\n%matplotlib notebook\nimport importlib\n\nassert importlib.util.find_spec('numpy') is not None , 'numpy not found'\nassert importlib.util.find_spec('matplotlib') is not None, 'matplotlib not found'\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfigure_intro = plt.figure('Example plot')\nplt.plot(np.random.randn(1000, 1))\nfigure_intro.canvas.draw()\n```\n\n\n \n\n\n\n\n\n\n## Assignment 0: Math recap (vector spaces) [2 Bonus Points]\n\nThis exercise is supposed to be very easy and is voluntary. There will be a similar exercise on every sheet.\nIt is intended to revise some basic mathematical notions that are assumed throughout this class and to allow you to check if you are comfortable with them.\nUsually you should have no problem to answer these questions offhand, but if you feel unsure, this is a good time to look them up again. You are always welcome to discuss questions with the tutors or in the practice session.\nAlso, if you have a (math) topic you would like to recap, please let us know.\n\n**a)** What is a *vector space*? What is the *basis* of a vector space and what is its *dimensionality*? Can you provide examples for finite- and infinite-dimensional vector spaces?\n\nA vector space or linear space is a collection of vectors for which **vector addition** and **scalar multiplication**, that satisfy a set of axioms, hold. A basis is a infinite or finite set of vectors that are *linearly independent* and can be combined to a sum also called *linear combination* to express any vector of that space. \n\nThe dimension of a vector space is the cardinality of its basis. An example for a finite-dimensional vector space is the *Euclidean space* $\\mathbb{R}^3$, which has the basis \n\n$$\\begin{Bmatrix}\n\\begin{pmatrix}\n1\\\\ 0\\\\ 0\n\\end{pmatrix},\n\\begin{pmatrix}\n0\\\\ 1\\\\ 0\n\\end{pmatrix},\n\\begin{pmatrix}\n0\\\\ 0\\\\ 1\n\\end{pmatrix}\n\\end{Bmatrix}$$ \n\nand thereby a dimension of 3. An infinte-dimensional vector space can be found in the *Hilbert space*.\n\n**b)** What is a *linear map*? What is the *image* and the *kernel* of such a map?\n\nA linear mapping is a function that maps between two modules that adheres to certain rules regrading addition and scalar multiplication listed below. \n\n\\begin{align}\nf(\\vec{u}+\\vec{v}) &= f(\\vec{u}) + f(\\vec{v})\\\\\nf(c\\vec{u}) &= cf(\\vec{u})\n\\end{align}\n\nThe kernel and image of such alinear mapping can be defined as follows: \n\n\\begin{align}\nker(f) &= \\{ x \\in V: f(x) = 0 \\}\\\\\nim(f) &= \\{ w \\in W: f(x) = w, x \\in V \\}\\\\\n\\end{align}\n\nMeaning that the kernel contains all vectors for which the operation f maps to 0 and the image holds all vectors in $W$ which can be mapped to from $V$ using f.\n\n**c)** What is a *matrix*? What is the relation to linear maps?\n\nA matrix is a $n\\times m$ collection of values that can be used to perform linear mappings. A popular application of matrices that are linear mappings is the rotation or scaling of 2 or 3-dimensional objects in space (computer graphics).\n\n## Assignment 1: Rosner test [5 Points]\n\nThe Rosner test is an iterative procedure to remove outliers of a data set via a z-test. In this exercise you will implement it and apply it to a sample data set.\n\n### a) Outliers\n\nFirst of all, think about why we use procedures like this and answer the following questions: \n\nWhat are causes for outliers? And what are our options to deal with them? \n\nA common cause for outliers is the imperfection of measuring technology, leading to incorrect data values. Other causes include the possibility that the data actually exhibits high variation or that the underlying model accounts for the extreme data values, while the data set *at hand* does not. \n\nThere are several options available to deal with outliers:\n* Remove them\n* Weight them according to their z-values (distance to $\\mu$ in terms of $\\sigma$)\n* Remove them and replace the missing data according to a specified procedure\n\n### b) Rosner test\n\nIn the following you find a stub for the implementation. The dataset is already generated. Now it is your turn to write the Rosner test and detect the outliers in the data. \n\n`data` is a `np.array` of `[x, y]` coordinates. `outliers` is a list of `[x, y]` coordinates.\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom math import fabs\n\n# generate dataset\ndata = list(zip(np.random.uniform(size=100), np.random.normal(size=100)))\ndata += list(zip(np.random.uniform(size=10), np.random.normal(0, 10, size=10)))\ndata = np.array(data)\noutliers = []\n\n# just to check if everything is pretty\nfig_rosner_data = plt.figure('The Dataset')\nplt.scatter(data[:,0], data[:,1], marker='x')\nplt.axis([0, 1, -20, 20])\nfig_rosner_data.canvas.draw()\n\n# Now find the outliers, add them to 'outliers', and remove them from 'data'.\nmax_iter = 100\nfor i in range(max_iter):\n median = np.median(data, axis=0)\n dev = np.std(data, axis=0)\n # Find max z item\n z = np.array([[fabs(coord[0]-median[0])/dev[0], fabs(coord[1]-median[1])/dev[1]] for coord in data])\n maxz = np.unravel_index(np.argmax(z, axis=None), z.shape)\n if z[maxz] > 3.5:\n outliers.append(data[maxz[0]])\n data = np.delete(data, maxz[0], axis=0)\n\n# plot results\noutliers = np.array(outliers)\nfig_rosner = plt.figure('Rosner Result')\nplt.scatter(data[:,0], data[:,1], c='b', marker='x', label='cleared data')\nplt.scatter(outliers[:,0], outliers[:,1], c='r', marker='x', label='outliers')\nplt.axis([0, 1, -20, 20])\nplt.legend(loc='lower right');\nfig_rosner.canvas.draw()\n```\n\n\n \n\n\n\n\n\n\n\n \n\n\n\n\n\n\n## Assignment 2: p-norm [5 Points]\n\nA very well known norm is the euclidean distance. However, it is not the only norm: It is in fact just one of many p-norms where $p = 2$. In this assignment you will take a look at other p-norms and see how they behave.\n\nImplement a function `pnorm` which expects a vector $x \\in \\mathcal{R}^n$ and a scalar $p \\geq 1, p \\in \\mathcal{R}$ and returns the p-norm of $x$ which is defined as:\n\n$$||x||_p = \\left(\\sum\\limits_{i=1}^n |x_i|^p \\right)^{\\frac{1}{p}}$$\n\n*Note:* Even though the norm is only defined for $p \\geq 1$, values $0 < p < 1$ are still interesting. In that case we can not talk about a norm anymore, as the triangle inequality ($||a|| + ||b|| \\geq ||a + b||$) does not hold. We will still take a look at some of these values, so your function should handle them as well.\n\n\n```python\nimport numpy as np\nfrom math import fsum, fabs\n\ndef pnorm(x, p):\n \"\"\"\n Calculates the p-norm of x.\n \n Args:\n x (array): the vector for which the norm is to be computed.\n p (float): the p-value (a positive real number).\n \n Returns:\n The p-norm of x.\n \"\"\" \n if p < 0:\n raise ValueError(\"P-Norm: p must be a positive number\")\n \n if not isinstance(x, list):\n x = [x];\n \n return pow(fsum([pow(fabs(a),p) for a in x]), 1.0/p)\n```\n\n\n```python\n# 1e-10 is 0.0000000001\nassert pnorm(1, 2) - 1 < 1e-10 , \"pnorm is incorrect for x = 1, p = 2\"\nassert pnorm(2, 2) - 2 < 1e-10 , \"pnorm is incorrect for x = 2, p = 2\"\nassert pnorm([2, 1], 2) - np.sqrt(5) < 1e-10 , \"pnorm is incorrect for x = [2, 1], p = 2\" \nassert pnorm(2, 0.5) - 2 < 1e-10 , \"pnorm is incorrect for x = 2, p = 0.5\"\n```\n\nImplement another function `pdist` which expects two vectors $x_0 \\in \\mathcal{R}^n, x_1 \\in \\mathcal{R}^n$ and a scalar $p \\geq 1, p \\in \\mathcal{R}$ and returns the distance between $x_0$ and $x_1$ on the p-norm defined by $p$. Again handle $0 < p < 1$ as well.\n\n\n```python\nimport numpy as np\nfrom math import fabs\n\ndef pdist(x0, x1, p):\n \"\"\"\n Calculates the distance between x0 and x1\n using the p-norm.\n \n Arguments:\n x0 (array): the first vector.\n x1 (array): the second vector.\n p (float): the p-value (a positive real number).\n \n Returns:\n The p-distance between x0 and x1.\n \"\"\"\n if p < 0:\n raise ValueError(\"P-Dist: p must be a positive number\")\n \n if not isinstance(x0, list):\n x0 = [x0];\n \n if not isinstance(x1, list):\n x1 = [x1];\n \n return pnorm([a-b for a,b in zip(x0,x1)], p)\n```\n\n\n```python\n# 1e-10 is 0.0000000001\nassert pdist(1, 2, 2) - 1 < 1e-10 , \"pdist is incorrect for x0 = 1, x1 = 2, p = 2\"\nassert pdist(2, 5, 2) - 3 < 1e-10 , \"pdist is incorrect for x0 = 2, x1 = 5, p = 2\"\nassert pdist([2, 1], [1, 2], 2) - np.sqrt(2) < 1e-10 , \"pdist is incorrect for x0 = [2, 1], x1 = [1, 2], p = 2\" \nassert pdist([2, 1], [0, 0], 2) - np.sqrt(5) < 1e-10 , \"pdist is incorrect for x0 = [2, 1], x1 = [0, 0], p = 2\" \nassert pdist(2, 0, 0.5) - 2 < 1e-10 , \"pdist is incorrect for x0 = 2, x1 = 0, p = 0.5\"\n```\n\nNow we will compare some different p-norms. Below is part of a code to plot data in nice scatter plots. \n\nYour task is to calculate the data to plot. The variable `data` is currently simply filled with zeros. Instead, fill it as follows:\n\n- Use the function `np.linspace()` to create a vector of `50` evenly distributed values between `-100` and `100` (inclusively).\n- Fill `data`: Data is basically the cartesian product of the vector you created before with itself filled up with each value's norm. It should have 2500 rows. Each of the 2500 rows should contain `[x, y, d]`, where `x` is the x coordinate and `y` the y coordinate of a point, and `d` the p-norm of `(x, y)`. Use either `pnorm` or `pdist` to calculate `d`.\n- Normalize the data in `data[:,2]` (i.e. all d-values) so that they are between 0 and 1.\n\nRun your code and take a look at your results. Darker colors mean that a value is closer to the center (0, 0) according to the p-norm used.\n\n*Hint:* To give you an idea of how `data` should look like, here is an example for three evenly distributed values between `-1` and `1` and a p-norm with `p = 2`.\n\nBefore normalization of the d-column:\n\n```python\ndata = np.array([[-1. -1. 1.41421356]\n [-1. 0. 1. ]\n [-1. 1. 1.41421356]\n [ 0. -1. 1. ]\n [ 0. 0. 0. ]\n [ 0. 1. 1. ]\n [ 1. -1. 1.41421356]\n [ 1. 0. 1. ]\n [ 1. 1. 1.41421356]])\n```\n\nAfter normalization of the d-column:\n\n```python\ndata = np.array([[-1. -1. 1. ]\n [-1. 0. 0.70710678]\n [-1. 1. 1. ]\n [ 0. -1. 0.70710678]\n [ 0. 0. 0. ]\n [ 0. 1. 0.70710678]\n [ 1. -1. 1. ]\n [ 1. 0. 0.70710678]\n [ 1. 1. 1. ]])\n```\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom matplotlib.colors import ColorConverter\nfrom itertools import product\n\ncolor = ColorConverter()\nfigure_norms = plt.figure('p-norm comparison')\n\n# create the linspace vector\nls = np.linspace(-100, 100)\n\nassert len(ls) == 50 , 'ls should be of length 50.'\nassert (min(ls), max(ls)) == (-100, 100) , 'ls should range from -100 to 100, inclusively.'\n\nfor i, p in enumerate([1/8, 1/4, 1/2, 1, 1.5, 2, 4, 8, 128]):\n # Create a numpy array containing useful values instead of zeros\n # tmp_data = np.array([x for x in product(ls, ls)])\n data = np.array([[x[0], x[1], pnorm([x[0], x[1]], p)] for x in product(ls, ls)])\n \n normalize = np.amax(data[:,2])\n data[:,2] /= normalize\n \n assert all(data[:,2] <= 1), 'The third column should be normalized.'\n\n # Plot the data.\n colors = [color.to_rgb((1, 1-a, 1-a)) for a in data[:,2]]\n a = plt.subplot(3, 3, i + 1)\n plt.scatter(data[:,0], data[:,1], marker='.', color=colors)\n a.set_ylim([-100, 100])\n a.set_xlim([-100, 100])\n a.set_title('{:.3g}-norm'.format(p))\n a.set_aspect('equal')\n plt.tight_layout()\n figure_norms.canvas.draw()\n```\n\n\n \n\n\n\n\n\n\n## Assignment 3: Expectation Maximization [10 Points]\n\nIn this assignment you will implement the Expectation Maximization algorithm (EM) for 1D data sets.\n\nAs some parts of this exercise would require some more knowledge of Python than what was already discussed in the practice sessions we built a small number of templates for you to use. However, if you prefer to do so you are also allowed to just go ahead and implement everything yourself! **Don't forget [task b)](#b%29-EM-and-missing-values)**!\n\n### a) Implement Expectation Maximization\n\nUse the next cell to implement your own solution or, if you want some more guidance, skip the next cell and continue the exercise at [Step 1) Load the data](#Step-1%29-Load-the-data).\n\nHere is an overview of what you have to do:\n\n**1) Load the data:**\n\nLoad the provided data set. It is stored in `em_normdistdata.txt`. We call the set $X$ and each individual data $x \\in X$.\n\n**2) Initialize EM:**\n\nInitialize three normal distributions whose parameters will be changed iteratively by the EM to converge close to the original distributions.\n\nEach normal distribution $j$ has three parameters: $\\mu_j$ (the mean), $\\sigma_j$ (the standard deviation), $\\alpha_j$ (the proportion of the normal distribution in the mixture, that means $\\sum\\limits_j\\alpha_j=1$).\n\nInitialize the three parameters using three random partitions $S_j$ of the data set. Calculate each $\\mu_j$ and $\\sigma_j$ and set $\\alpha_j = \\frac{|S_j|}{|X|}$.\n\n**3) Implement the expectation step:**\n\nPerform a soft classification of the data samples with the three normal distributions. That means: Calculate the likelihood that a data sample $x_i$ belongs to distribution $j$ given parameters $\\mu_j$ and $\\sigma_j$. Or in other words, what is the likelihood of $x_i$ to be drawn from $N_j(\\mu_j, \\sigma_j)$? When you got the likelihood, weight the result by $\\alpha_j$.\n\nAs a last step normalize the results such that the likelihoods of a data sample $x_i$ sum up to $1$.\n\n**4) Implement the maximization step:**\n\nIn the maximization step each $\\mu_j$, $\\sigma_j$ and $\\alpha_j$ is updated. First calculate the new means:\n\n$$\\mu_j = \\frac{1}{\\sum\\limits_{i=1}^{|X|} p_{ij}} \\sum\\limits_{i=1}^{|X|} p_{ij}x_i$$\n\nThat means $\\mu_j$ is the weighted mean of all samples, where the weight is their likelihood of belonging to distribution $j$.\n\nThen calculate the new $\\sigma_j$. Each new $\\sigma_j$ is the standard deviation of the normal distribution with the new $\\mu_j$, so for the calculation you already use the new $\\mu_j$:\n\n$$\\sigma_j = \\sqrt{ \\frac{1}{\\sum\\limits_{i=1}^{|X|} p_{ij}} \\sum\\limits_{i=1}^{|X|} p_{ij} \\left(x_i - \\mu_j\\right)^2 }$$\n\nTo calculate the new $\\alpha_j$ for each distribution, just take the mean of $p_j$ for each normal distribution $j$.\n\n**5) Perform the complete EM and plot your results:**\n\nBuild a loop around the iterative procedure of expectation and maximization which stops when the changes in all $\\mu_j$ and $\\sigma_j$ are sufficiently small enough.\n\nPlot your results after each step and mark which data points belong to which normal distribution. If you don't get it to work, just plot your final solution of the distributions.\n\n\n```python\n# Free space to implement your own solution -- either use this OR use the following step by step guide. \n# You may use scipy.stats.norm.pdf for your own implementation.\n\n\n\n\n```\n\n#### Step 1) Load the data\n\n\nLoad the provided data set. It is stored in `em_normdistdata.txt`. We call the set $X$ and each individual data $x \\in X$. \n\n*Hint:* Figure out a way on how numpy can load text data.\n\n\n```python\nimport numpy as np\n\ndef load_data(file_name):\n \"\"\"\n Loads the data stored in file_name into a numpy array.\n \"\"\"\n return np.loadtxt(file_name)\n\nassert load_data('em_normdistdata.txt').shape == (200,) , \"The data was not properly loaded.\"\n```\n\n*Optional:* The data consists of 200 data points drawn from three normal distributions. To get a feeling for the data set you can plot the data with the following cell. Change the number of bins to get a rough idea of how the three distributions might look like.\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndata = load_data('em_normdistdata.txt')\n\nfig_data_test = plt.figure('Data overview')\nplt.hist(data, bins=5)\nfig_data_test.canvas.draw()\n```\n\n\n \n\n\n\n\n\n\n#### Step 2) Initialize EM\n\nBelow is a class definition `NormPDF` which represents the probability density function (pdf) of the normal distribution with an additional parameter $\\alpha$. The class is explained in the next cells.\n\n\n```python\nimport numpy as np\nclass NormPDF():\n \"\"\"\n A representation of the probability density function of the normal distribution\n for the EM Algorithm.\n \"\"\"\n\n def __init__(self, mu=0, sigma=1, alpha=1):\n \"\"\"\n Initializes the normal distribution with mu, sigma and alpha.\n The defaults are 0, 1, and 1 respectively.\n \"\"\"\n self.mu = mu\n self.sigma = sigma\n self.alpha = alpha\n\n\n def __call__(self, x):\n \"\"\"\n Returns the evaluation of this normal distribution at x.\n Does not take alpha into account!\n \"\"\"\n return np.exp(-(x - self.mu) ** 2 / (2 * self.sigma ** 2)) / (np.sqrt(np.pi * 2) * self.sigma)\n\n\n def __repr__(self):\n \"\"\"\n A simple string representation of this instance.\n \"\"\"\n return 'NormPDF({self.mu:.2f},{self.sigma:.2f},{self.alpha:.2f})'.format(self=self)\n```\n\nThe class `NormPDF` offers several class methods: `__init__`, `__call__`, `__repr__`. They are all special Python functions which are overloaded so they can be used in a nice way. Note that all methods take as the first parameter `self`: this is just the python way of passing the instance itself to the method so that it becomes possible to access its data. You can always ignore it for now and just assume that the methods only need the parameters which follow.\n\n`__init__`: This is the constructor. When a new instance of the class is created this method is used. It takes the parameters `mu`, `sigma`, and `alpha`. Note that if you leave out parameters, they will be set to some default values.\nSo you can create `NormPDF` instances like this:\n\n\n```python\na = NormPDF() # No parameters: mu = 0, sigma = 1, alpha = 1\nb = NormPDF(1) # mu = 1, sigma = 1, alpha = 1\nc = NormPDF(1, alpha=0.4) # skips sigma but sets alpha, thus: mu = 1, sigma = 1, alpha = 0.4\nd = NormPDF(0, 0.5) # mu = 0, sigma = 0.5, alpha = 1\ne = NormPDF(0, 0.5, 0.9) # mu = 0, sigma = 0.5, alpha = 0.9\n```\n\n`__call__`: This is a very cool feature of Python. By implementing this method one can make an instance *callable*. That basically means one can use it as if it was a function. The `NormPDF` instances can be called with an x value (or a numpy array of x values) to get the evaluation of the normal distribution at x.\n\n\n```python\nnormpdf = NormPDF()\nprint(normpdf(0))\nprint(normpdf(0.5))\nprint(normpdf(np.linspace(-2, 2, 10)))\n```\n\n 0.3989422804014327\n 0.3520653267642995\n [0.05399097 0.11897819 0.21519246 0.31944801 0.38921247 0.38921247\n 0.31944801 0.21519246 0.11897819 0.05399097]\n\n\n`__repr__`: This method will be used in Python when one calls `repr(NormPDF())`. As long as `__str__` is not implemented (which you saw in last week's sheet) `str(NormPDF())` will also use this method. This comes in handy for printing:\n\n\n```python\nnormpdf1 = NormPDF()\nnormpdf2 = NormPDF(1, 0.5, 0.9)\nprint(normpdf1)\nprint([normpdf1, normpdf2])\n```\n\n NormPDF(0.00,1.00,1.00)\n [NormPDF(0.00,1.00,1.00), NormPDF(1.00,0.50,0.90)]\n\n\nIt is also possible to change the values of an instance of the NormPDF:\n\n\n```python\nnormpdf1 = NormPDF()\nprint(normpdf1)\nprint(normpdf1(np.linspace(-2, 2, 10)))\n\nnormpdf1.mu = 1\nnormpdf1.sigma = 2\nnormpdf1.alpha = 0.9\nprint(normpdf1)\nprint(normpdf1(np.linspace(-2, 2, 10)))\n```\n\n NormPDF(0.00,1.00,1.00)\n [0.05399097 0.11897819 0.21519246 0.31944801 0.38921247 0.38921247\n 0.31944801 0.21519246 0.11897819 0.05399097]\n NormPDF(1.00,2.00,0.90)\n [0.0647588 0.08817395 0.11427077 0.14095594 0.16549503 0.18494385\n 0.19671986 0.19916355 0.19192205 0.17603266]\n\n\nNow that you know how the `NormPDF` class works, it is time for the implementation of the initialization function. Here is the task again:\n\nWrite a function `gaussians = initialize_EM(data, num_distributions)` to initialize the EM.\n\nEach normal distribution $j$ has three parameters: $\\mu_j$ (the mean), $\\sigma_j$ (the standard deviation), $\\alpha_j$ (the proportion of the normal distribution in the mixture, that means $\\sum\\limits_j\\alpha_j=1$).\nInitialize the three parameters using three random partitions $S_j$ of the data set. Calculate each $\\mu_j$ and $\\sigma_j$ and set $\\alpha_j = \\frac{|S_j|}{|X|}$.\n\n\n```python\ndef initialize_EM(data, num_distributions):\n \"\"\"\n Initializes the EM algorithm by calculating num_distributions NormPDFs\n from a random partitioning of data. I.e., the data set is randomly\n divided into num_distribution parts, and each part is used to initialize\n mean, standard deviation and alpha parameter of a NormPDF object.\n \n Args:\n data (array): A collection of data.\n num_distributions (int): The number of distributions to return.\n \n Returns:\n A list of num_distribution NormPDF objects, initialized from a\n random partioning of the data.\n \"\"\"\n gaussians = []\n size = len(data)\n \n # Shuffle and split data to get 'randomized' partitioning\n np.random.shuffle(data)\n subsets = np.array_split(data, num_distributions)\n # For each subset, generate a pdf using the contained data\n for aset in subsets:\n gaussians.append(NormPDF(np.mean(aset), np.std(aset), len(aset)/size))\n \n return gaussians\n\n\nnormpdfs_ = initialize_EM(np.linspace(-1, 1, 100), 2)\nassert len(normpdfs_) == 2, \"The number of initialized distributions is not correct.\"\n# 1e-10 is 0.0000000001\nassert abs(1 - sum([normpdf.alpha for normpdf in normpdfs_])) < 1e-10 , \"Sum of all alphas is not 1.0!\"\n```\n\n#### Step 3) Implement the expectation step\n\nPerform a soft classification of the data samples with the normal distributions. That means: Calculate the likelihood that a data sample $x_i$ belongs to distribution $j$ given parameters $\\mu_j$ and $\\sigma_j$. Or in other words, what is the likelihood of $x_i$ to be drawn from $N_j(\\mu_j, \\sigma_j)$? When you got the likelihood, weight the result by $\\alpha_j$.\n\nAs a last step normalize the results such that the likelihoods of a data sample $x_i$ sum up to $1$.\n\n*Hint:* Store the data in a different array before you normalize it to not run into problems with partly normalized data.\n\n\n```python\nfrom math import fsum\n\ndef expectation_step(gaussians, data):\n \"\"\"\n Performs the expectation step of the EM.\n \n Args:\n gaussians (list): A list of NormPDF objects.\n data (array): The data vector.\n \n Returns:\n An array of shape (len(data), len(gaussians))\n which contains normalized likelihoods for each sample\n to denote to which of the normal distributions it \n most likely belongs to.\n \"\"\"\n tmp = np.array([[g(entry)*g.alpha for g in gaussians] for entry in data]) \n expectation = np.array(tmp)\n \n for i in range(len(data)):\n whole = fsum(tmp[i,:])\n expectation[i,:] = [x/whole for x in tmp[i,:]]\n \n return expectation\n\nassert expectation_step([NormPDF(), NormPDF()], np.linspace(-2, 2, 100)).shape == (100, 2) , \"Shape is not correct!\"\n```\n\n#### Step 4) Implement the maximization step\n\nIn the maximization step each $\\mu_j$, $\\sigma_j$ and $\\alpha_j$ is updated. First calculate the new means:\n\n$$\\mu_j = \\frac{1}{\\sum\\limits_{i=1}^{|X|} p_{ij}} \\sum\\limits_{i=1}^{|X|} p_{ij}x_i$$\n\nThat means $\\mu_j$ is the weighted mean of all samples, where the weight is their likelihood of belonging to distribution $j$.\n\nThen calculate the new $\\sigma_j$. Each new $\\sigma_j$ is the standard deviation of the normal distribution with the new $\\mu_j$, so for the calculation you already use the new $\\mu_j$:\n\n$$\\sigma_j = \\sqrt{ \\frac{1}{\\sum\\limits_{i=1}^{|X|} p_{ij}} \\sum\\limits_{i=1}^{|X|} p_{ij} \\left(x_i - \\mu_j\\right)^2 }$$\n\nTo calculate the new $\\alpha_j$ for each distribution, just take the mean of $p_j$ for each normal distribution $j$.\n\n**Caution:** For the next step it is necessary to know how much all $\\mu$ and $\\sigma$ changed. For that the function `maximization_step` should return a numpy array of those (absolute) changes. For example if $\\mu_0$ changed from 0.1 to 0.15, $\\sigma_0$ from 1 to 0.9, $\\mu_1$ from 0.5 to 0.6, and $\\sigma_1$, $\\mu_2$, and $\\sigma_2$ stayed the same, we expect the function to return `np.array([0.05, 0.1, 0.1, 0, 0, 0])` (however, the order is not important).\n\n\n```python\nfrom math import sqrt, fabs, fsum\n\ndef weighted_mean(data, pij):\n \"\"\"\n Calculates the new weighted mean\n \n Args:\n data (array): the data vector\n pij (array): expected values for the data\n \n Returns:\n The new weighted mean for the distribution\n \"\"\"\n return fsum([x*y for x,y in zip(data,pij)])/fsum(pij)\n\ndef std_dev(mu, data, pij):\n \"\"\"\n Calculates the new standard deviation\n \n Args:\n mu (float): mean\n data (array): the data vector\n pij (array): expected values for the data\n \n Returns:\n The new weighted mean for the distribution\n \"\"\"\n return sqrt(fsum([y*pow(x-mu, 2) for x,y in zip(data,pij)])/fsum(pij))\n\ndef maximization_step(gaussians, data, expectation):\n \"\"\"\n Performs the maximization step of the EM.\n Modifies the gaussians by updating their mus and sigmas.\n \n Args:\n gaussians (list): A list of NormPDF objects.\n data (array): The data vector.\n expectation (array): The expectation values for data element\n (as computed by expectation_step()).\n\n Returns:\n A numpy array of absolute changes in any mu or sigma, \n that means the returned array has twice as many elements as\n the supplied list of gaussians.\n \"\"\"\n changes = []\n for i in range(len(gaussians)):\n new_mu = weighted_mean(data, expectation[:,i])\n new_sigma = std_dev(new_mu, data, expectation[:,i])\n gaussians[i].alpha = sum(expectation[:,i])/len(data)\n \n changes.append(fabs(gaussians[i].mu - new_mu))\n changes.append(fabs(gaussians[i].sigma - new_sigma))\n gaussians[i].mu = new_mu\n gaussians[i].sigma = new_sigma\n \n return np.array(changes)\n```\n\n**5) Perform the complete EM and plot your results:**\n\nInitialize three normal distributions whose parameters will be changed iteratively by the EM to converge close to the original distributions.\n\nBuild a loop around the iterative procedure of expectation and maximization which stops when the changes in all $\\mu_j$ and $\\sigma_j$ are sufficiently small enough.\n\nPlot your results after each step and mark which data points belong to which normal distribution. If you don't get it to work, just plot your final solution.\n\n*Hint:* Remember to load the data and initialize the EM before the loop.\n\n*Hint:* A function `plot_intermediate_result` to plot your result after each step is already defined in the next cell. Take a look at what arguments it takes and try to use it in your loop.\n\n*Hint:* To plot your final result the first three images and corresponding code examples on the tutorial of [`plt.plot(...)`](http://matplotlib.org/users/pyplot_tutorial.html) should help you.\n\n*Optional:* Run the code multiple times. If your results are changing, use `np.random.seed(2)` in the beginning of the cell to get consistent results (any other integer will work as well, but 2 has some good results for the example solutions).\n\n\n```python\n%matplotlib notebook\nimport time\nimport itertools\n\nimport numpy as np\nimport matplotlib.pyplot as plt\n# Sets the random seed to a fix value to make results consistent\n# np.random.seed(2)\n\ncolors = itertools.cycle(['r', 'g', 'b', 'c', 'm', 'y', 'k'])\nfigure, axis = plt.subplots(1)\naxis.set_xlim(-5, 5)\naxis.set_ylim(-0.2, 4)\naxis.set_title('Intermediate Results')\nfinal_figure = plt.figure('Final Result')\n\ndef plot_intermediate_result(gaussians, data, mapping):\n \"\"\"\n Gets a list of gaussians and data input. The mapping\n parameter is a list of indices of gaussians. Each value\n corresponds to the data value at the same position and \n maps this data value to the proper gaussian.\n \"\"\"\n x = np.linspace(-5, 5, 100)\n if len(axis.lines):\n for j, N in enumerate(gaussians):\n axis.lines[j * 2].set_xdata(x)\n axis.lines[j * 2].set_ydata(N(x))\n axis.lines[j * 2 + 1].set_xdata(data[mapping == j])\n axis.lines[j * 2 + 1].set_ydata([0] * len(data[mapping == j]))\n else:\n for j, N in enumerate(gaussians):\n axis.plot(x, N(x), data[mapping == j], [0] * len(data[mapping == j]), 'x', color=next(colors), markersize=5)\n figure.canvas.draw()\n time.sleep(1.0)\n\ndef plot_final(gaussians, data, mapping):\n x = np.linspace(-5, 5, 100)\n for j, g in enumerate(gaussians):\n plt.plot(x, g(x), data[mapping == j], [0] * len(data[mapping == j]), 'x', color=next(colors), markersize=5)\n final_figure.canvas.draw()\n \n# Perform the initialization.\ndata = load_data('em_normdistdata.txt')\ngaussians = initialize_EM(data, 3)\n\n# Loop until the changes are small enough.\neps = 0.05\nchanges = [float('inf')] * 2\nexpectation = []\nwhile max(changes) > eps:\n # E-step\n expectation = expectation_step(gaussians, data)\n # M-step\n changes = maximization_step(gaussians, data, expectation)\n # Optional: Calculate the parameters to update the plot and call the function to do it.\n plot_intermediate_result(gaussians, data, np.argmax(expectation, 1))\n\n# Plot your final result and print the final parameters.\nplot_final(gaussians, data, np.argmax(expectation, 1))\n```\n\n\n \n\n\n\n\n\n\n\n \n\n\n\n\n\n\n### b) EM and missing values\n\nDescribe in your own words: How does the EM-algorithm deal with the missing value problem?\n\nIn order to deal with missing values, the EM-algorithm estimates the distribution underlying the data and then generates numbers that are sampled from that distribution to fill up the missing values. \n\nTo find the distribution, or rather the correct parameters of that distribution, the algorithm makes an initial guess and then, in each iteration, the probability for each data point to belong to a distribution is calculated. That result is used to refactor each distribution's parameters (in our case $\\mu$ and $\\sigma$) by recalculating them with weighted samples, the weight being that samples' probability of belonging to that distribution.\n", "meta": {"hexsha": "5180a9792f7b93729257c238272bc9ddc6ccd615", "size": 701482, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "sheet_03/sheet_03_machine-learning.ipynb", "max_stars_repo_name": "ArielMant0/ml2018", "max_stars_repo_head_hexsha": "676dcf028766c369f94c164529ce16c4ef7716aa", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sheet_03/sheet_03_machine-learning.ipynb", "max_issues_repo_name": "ArielMant0/ml2018", "max_issues_repo_head_hexsha": "676dcf028766c369f94c164529ce16c4ef7716aa", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sheet_03/sheet_03_machine-learning.ipynb", "max_forks_repo_name": "ArielMant0/ml2018", "max_forks_repo_head_hexsha": "676dcf028766c369f94c164529ce16c4ef7716aa", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 97.9723463687, "max_line_length": 129295, "alphanum_fraction": 0.7620067229, "converted": true, "num_tokens": 8916, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4225046348141882, "lm_q2_score": 0.2942149597859341, "lm_q1q2_score": 0.12430718414122716}}
{"text": "# Introduction\n\nClassical mechanics is a topic which has been taught intensively over\nseveral centuries. It is, with its many variants and ways of\npresenting the educational material, normally the first **real** physics\ncourse many of us meet and it lays the foundation for further physics\nstudies. Many of the equations and ways of reasoning about the\nunderlying laws of motion and pertinent forces, shape our approaches and understanding\nof the scientific method and discourse, as well as the way we develop our insights\nand deeper understanding about physical systems. \n\nThere is a wealth of\nwell-tested (from both a physics point of view and a pedagogical\nstandpoint) exercises and problems which can be solved\nanalytically. However, many of these problems represent idealized and\nless realistic situations. The large majority of these problems are\nsolved by paper and pencil and are traditionally aimed\nat what we normally refer to as continuous models from which we may find an analytical solution. As a consequence,\nwhen teaching mechanics, it implies that we can seldomly venture beyond an idealized case\nin order to develop our understandings and insights about the\nunderlying forces and laws of motion.\n\n\nOn the other hand, numerical algorithms call for approximate discrete\nmodels and much of the development of methods for continuous models\nare nowadays being replaced by methods for discrete models in science and\nindustry, simply because **much larger classes of problems can be addressed** with discrete models, often by simpler and more\ngeneric methodologies.\n\nAs we will see below, when properly scaling the equations at hand,\ndiscrete models open up for more advanced abstractions and the possibility to\nstudy real life systems, with the added bonus that we can explore and\ndeepen our basic understanding of various physical systems\n\nAnalytical solutions are as important as before. In addition, such\nsolutions provide us with invaluable benchmarks and tests for our\ndiscrete models. Such benchmarks, as we will see below, allow us \nto discuss possible sources of errors and their behaviors. And\nfinally, since most of our models are based on various algorithms from\nnumerical mathematics, we have a unique oppotunity to gain a deeper\nunderstanding of the mathematical approaches we are using.\n\n\n\nWith computing and data science as important elements in essentially\nall aspects of a modern society, we could then try to define Computing as\n**solving scientific problems using all possible tools, including\nsymbolic computing, computers and numerical algorithms, and analytical\npaper and pencil solutions**. \nComputing provides us with the tools to develope our own understanding of the scientific method by enhancing algorithmic thinking.\n\n\nThe way we will teach this course reflects\nthis definition of computing. The course contains both classical paper\nand pencil exercises as well as computational projects and exercises. The\nhope is that this will allow you to explore the physics of systems\ngoverned by the degrees of freedom of classical mechanics at a deeper\nlevel, and that these insights about the scientific method will help\nyou to develop a better understanding of how the underlying forces and\nequations of motion and how they impact a given system. Furthermore, by introducing various numerical methods\nvia computational projects and exercises, we aim at developing your competences and skills about these topics.\n\n\nThese competences will enable you to\n\n* understand how algorithms are used to solve mathematical problems,\n\n* derive, verify, and implement algorithms,\n\n* understand what can go wrong with algorithms,\n\n* use these algorithms to construct reproducible scientific outcomes and to engage in science in ethical ways, and\n\n* think algorithmically for the purposes of gaining deeper insights about scientific problems.\n\nAll these elements are central for maturing and gaining a better understanding of the modern scientific process *per se*.\n\nThe power of the scientific method lies in identifying a given problem\nas a special case of an abstract class of problems, identifying\ngeneral solution methods for this class of problems, and applying a\ngeneral method to the specific problem (applying means, in the case of\ncomputing, calculations by pen and paper, symbolic computing, or\nnumerical computing by ready-made and/or self-written software). This\ngeneric view on problems and methods is particularly important for\nunderstanding how to apply available, generic software to solve a\nparticular problem.\n\n*However, verification of algorithms and understanding their limitations requires much of the classical knowledge about continuous models.*\n\n\n\n## A well-known examples to illustrate many of the above concepts\n\nBefore we venture into a reminder on Python and mechanics relevant applications, let us briefly outline some of the\nabovementioned topics using an example many of you may have seen before in for example CMSE201. \nA simple algorithm for integration is the Trapezoidal rule. \nIntegration of a function $f(x)$ by the Trapezoidal Rule is given by following algorithm for an interval $x \\in [a,b]$\n\n$$\n\\int_a^b(f(x) dx = \\frac{1}{2}\\left [f(a)+2f(a+h)+\\dots+2f(b-h)+f(b)\\right] +O(h^2),\n$$\n\nwhere $h$ is the so-called stepsize defined by the number of integration points $N$ as $h=(b-a)/(n)$.\nPython offers an extremely versatile programming environment, allowing for\nthe inclusion of analytical studies in a numerical program. Here we show an\nexample code with the **trapezoidal rule**. We use also **SymPy** to evaluate the exact value of the integral and compute the absolute error\nwith respect to the numerically evaluated one of the integral\n$\\int_0^1 dx x^2 = 1/3$.\nThe following code for the trapezoidal rule allows you to plot the relative error by comparing with the exact result. By increasing to $10^8$ points one arrives at a region where numerical errors start to accumulate.\n\n\n```python\n%matplotlib inline\n\nfrom math import log10\nimport numpy as np\nfrom sympy import Symbol, integrate\nimport matplotlib.pyplot as plt\n# function for the trapezoidal rule\ndef Trapez(a,b,f,n):\n h = (b-a)/float(n)\n s = 0\n x = a\n for i in range(1,n,1):\n x = x+h\n s = s+ f(x)\n s = 0.5*(f(a)+f(b)) +s\n return h*s\n# function to compute pi\ndef function(x):\n return x*x\n# define integration limits\na = 0.0; b = 1.0;\n# find result from sympy\n# define x as a symbol to be used by sympy\nx = Symbol('x')\nexact = integrate(function(x), (x, a, b))\n# set up the arrays for plotting the relative error\nn = np.zeros(9); y = np.zeros(9);\n# find the relative error as function of integration points\nfor i in range(1, 8, 1):\n npts = 10**i\n result = Trapez(a,b,function,npts)\n RelativeError = abs((exact-result)/exact)\n n[i] = log10(npts); y[i] = log10(RelativeError);\nplt.plot(n,y, 'ro')\nplt.xlabel('n')\nplt.ylabel('Relative error')\nplt.show()\n```\n\nThis example shows the potential of combining numerical algorithms with symbolic calculations, allowing us to \n\n* Validate and verify their algorithms. \n\n* Including concepts like unit testing, one has the possibility to test and test several or all parts of the code.\n\n* Validation and verification are then included *naturally* and one can develop a better attitude to what is meant with an ethically sound scientific approach.\n\n* The above example allows the student to also test the mathematical error of the algorithm for the trapezoidal rule by changing the number of integration points. The students get **trained from day one to think error analysis**. \n\n* With a Jupyter notebook you can keep exploring similar examples and turn them in as your own notebooks. \n\nIn this process we can easily bake in\n1. How to structure a code in terms of functions\n\n2. How to make a module\n\n3. How to read input data flexibly from the command line\n\n4. How to create graphical/web user interfaces\n\n5. How to write unit tests (test functions or doctests)\n\n6. How to refactor code in terms of classes (instead of functions only)\n\n7. How to conduct and automate large-scale numerical experiments\n\n8. How to write scientific reports in various formats (LaTeX, HTML)\n\nThe conventions and techniques outlined here will save you a lot of time when you incrementally extend software over time from simpler to more complicated problems. In particular, you will benefit from many good habits:\n1. New code is added in a modular fashion to a library (modules)\n\n2. Programs are run through convenient user interfaces\n\n3. It takes one quick command to let all your code undergo heavy testing \n\n4. Tedious manual work with running programs is automated,\n\n5. Your scientific investigations are reproducible, scientific reports with top quality typesetting are produced both for paper and electronic devices.\n", "meta": {"hexsha": "53c6ddbf7324ab13438fcb0d7846d91b905a196d", "size": 18609, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/src/LectureNotes/_build/jupyter_execute/testbook/chapter1.ipynb", "max_stars_repo_name": "anacost/MachineLearning", "max_stars_repo_head_hexsha": "89e1c3637fe302c2b15b96bf89c8a01d2d693f29", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/src/LectureNotes/_build/jupyter_execute/testbook/chapter1.ipynb", "max_issues_repo_name": "anacost/MachineLearning", "max_issues_repo_head_hexsha": "89e1c3637fe302c2b15b96bf89c8a01d2d693f29", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/src/LectureNotes/_build/jupyter_execute/testbook/chapter1.ipynb", "max_forks_repo_name": "anacost/MachineLearning", "max_forks_repo_head_hexsha": "89e1c3637fe302c2b15b96bf89c8a01d2d693f29", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-04T16:21:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-04T16:21:16.000Z", "avg_line_length": 73.5533596838, "max_line_length": 7020, "alphanum_fraction": 0.778494277, "converted": true, "num_tokens": 1914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3629692055196168, "lm_q2_score": 0.3415824927356586, "lm_q1q2_score": 0.12398392600767229}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ntag = HTML('''\nPromijeni vidljivost ovdje .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n\n```\n\n\n\nPromijeni vidljivost ovdje .\n\n\n## Unutarnja stabilnost\n\nKoncept stabilnosti bilježi ponašanje evolucije stanja sustava kada je isti \"izbačen\" iz ravnotežnog stanja: stabilnost opisuje divergira li evolucija stanja koja nastaje nakon poremećaja iz točke ravnoteže ili ne.\n\n### Definicija\nS obzirom na vremenski nepromjenjiv dinamički sustav opisan vektorom stanja $x(t)\\in \\mathbb{R}^n$, točkom ravnoteže $x_e$, početnim stanjem $x_0$ i početnim vremenom $t_0$, ako vrijedi\n\n$$\n\\forall \\, \\epsilon \\in \\mathbb{R}, \\, \\epsilon > 0 \\quad \\exists \\delta \\in \\mathbb{R}, \\, \\delta > 0 : \\quad ||x_0-x_e|| < \\delta \\, \\Rightarrow \\, ||x(t)-x_e|| < \\epsilon \\quad \\forall t \\ge t_0\n$$\nto bi se moglo protumačiti kao: ako postoji dovoljno mala početna perturbacija $\\delta$ od točke ravnoteže takva da evolucija stanja $x(t)$ od točke poremećaja ne odlazi predaleko (više od $\\epsilon$) od same ravnoteže, tada je točka ravnoteže stabilna.\n\nAko se također dogodi $\\lim_{t\\to\\infty}||x(t)-x_e|| = 0$, što se može protumačiti kao: evolucija stanja se vraća natrag u točku ravnoteže, tada se kaže da je ravnoteža asimptotski stabilna.\n\nU slučaju linearnih vremenski nepromjenjivih sustava:\n\n\n\\begin{cases}\n\\dot{x} = Ax +Bu \\\\\ny = Cx + Du,\n\\end{cases}\n\nmoguće je dokazati da stabilnost jedne točke ravnoteže podrazumijeva stabilnost svih točaka ravnoteže, pa možemo govoriti o stabilnosti sustava čak i ako je, općenito, svojstvo stabilnosti povezano s točkom ravnoteže. Posebnost ovog linearnog sustava posljedica je činjenice da je evolucija ove vrste sustava strogo povezana sa svojstvenim vrijednostima matrice dinamike $A$, koje su invarijantne s obzirom na rotaciju, translaciju, početne uvjete i vrijeme.\n\n\n\nPodsjetite se što je objašnjeno u primjeru o modalnoj analizi:\n\n> Rješenje diferencijalne jednadžbe (u zatvorenoj formi), od početnog vremena $t_0$, s početnim uvjetima $x(t_0)$, je \n$$\nx(t) = e^{A(t-t_0)}x(t_0).\n$$ Matrica $e^{A(t-t_0)}x(t_0)$ se sastoji od linearnih kombinacija funkcije vremena $t$, svake tipa: $$e^{\\lambda t},$$ gdje su $\\lambda$-e svojstvene vrijednosti matrice $A$; ove su funckije modovi sustava.\n\nstoga:\n- linearni dinamički sustav stabilan je ako i samo ako svi njegovi modovi nisu divergentni,\n- linearni dinamički sustav je asimptotski stabilan ako i samo ako su svi njegovi modovi konvergentni,\n- linearni dinamički sustav je nestabilan ako ima barem jedan divergentni mod.\n\ni, s obzirom na svojstvene vrijednosti matrice dinamike, to se događa ako:\n- sve svojstvene vrijednosti matrice $A$ pripadaju zatvorenoj lijevoj polovici kompleksne ravnine (tj. realna vrijednost im je negativna ili nula), a, u slučaju da imaju realnu vrijednost nula, njihova je algebarska višestrukost ista kao geometrijska višestrukost (množnost), ili, ekvivalentno tome, imaju skalarne blokove u Jordanovom obliku;\n- sve svojstvene vrijednosti pripadaju otvorenoj lijevoj polovici imaginarne ravnine, odnosno imaju strogo negativne realne dijelove;\n- barem jedna svojstvena vrijednost ima pozitivan realni dio ili postoje svojstvene vrijednosti s realnom vrijednošću 0 i neskalarni Jordanovi blokovi.\n\n\nOvaj interaktivni primjer predstavlja matricu dinamike $A$ koju je moguće uređivati, a prikazuje slobodni odziv sustava uz odgovarajuće svojstvene vrijednosti.\n\n\n\n### Kako koristiti ovaj interaktivni primjer?\n- Pokušajte promijeniti svojstvene vrijednosti i početni uvjet $x_0$ i pogledajte kako se mijenja odziv.\n\n\n```python\n%matplotlib inline\n#%matplotlib notebook \nimport control as control\nimport numpy\nimport sympy as sym\nfrom IPython.display import display, Markdown\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\n\n\n#print a matrix latex-like\ndef bmatrix(a):\n \"\"\"Returns a LaTeX bmatrix - by Damir Arbula (ICCT project)\n\n :a: numpy array\n :returns: LaTeX bmatrix as a string\n \"\"\"\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{bmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{bmatrix}']\n return '\\n'.join(rv)\n\n\n# Display formatted matrix: \ndef vmatrix(a):\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{vmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{vmatrix}']\n return '\\n'.join(rv)\n\n\n#matrixWidget is a matrix looking widget built with a VBox of HBox(es) that returns a numPy array as value !\nclass matrixWidget(widgets.VBox):\n def updateM(self,change):\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.M_[irow,icol] = self.children[irow].children[icol].value\n #print(self.M_[irow,icol])\n self.value = self.M_\n\n def dummychangecallback(self,change):\n pass\n \n \n def __init__(self,n,m):\n self.n = n\n self.m = m\n self.M_ = numpy.matrix(numpy.zeros((self.n,self.m)))\n self.value = self.M_\n widgets.VBox.__init__(self,\n children = [\n widgets.HBox(children = \n [widgets.FloatText(value=0.0, layout=widgets.Layout(width='90px')) for i in range(m)]\n ) \n for j in range(n)\n ])\n \n #fill in widgets and tell interact to call updateM each time a children changes value\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n self.children[irow].children[icol].observe(self.updateM, names='value')\n #value = Unicode('example@example.com', help=\"The email value.\").tag(sync=True)\n self.observe(self.updateM, names='value', type= 'All')\n \n def setM(self, newM):\n #disable callbacks, change values, and reenable\n self.unobserve(self.updateM, names='value', type= 'All')\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].unobserve(self.updateM, names='value')\n self.M_ = newM\n self.value = self.M_\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].observe(self.updateM, names='value')\n self.observe(self.updateM, names='value', type= 'All') \n\n #self.children[irow].children[icol].observe(self.updateM, names='value')\n\n \n#overlaod class for state space systems that DO NOT remove \"useless\" states (what \"professor\" of automatic control would do this?)\nclass sss(control.StateSpace):\n def __init__(self,*args):\n #call base class init constructor\n control.StateSpace.__init__(self,*args)\n #disable function below in base class\n def _remove_useless_states(self):\n pass\n```\n\n\n```python\n# Preparatory cell\n\nA = numpy.matrix([[0,1],[-2/5,-1/5]])\nX0 = numpy.matrix('5; 3')\n\nAw = matrixWidget(2,2)\nAw.setM(A)\nX0w = matrixWidget(2,1)\nX0w.setM(X0)\n```\n\n\n```python\n# Misc\n\n#create dummy widget \nDW = widgets.FloatText(layout=widgets.Layout(width='0px', height='0px'))\n\n#create button widget\nSTART = widgets.Button(\n description='Test',\n disabled=False,\n button_style='', # 'success', 'info', 'warning', 'danger' or ''\n tooltip='Test',\n icon='check'\n)\n \ndef on_start_button_clicked(b):\n #This is a workaround to have intreactive_output call the callback:\n # force the value of the dummy widget to change\n if DW.value> 0 :\n DW.value = -1\n else: \n DW.value = 1\n pass\nSTART.on_click(on_start_button_clicked)\n```\n\n\n```python\n# Main cell\n\ndef main_callback(A, X0, DW):\n sols = numpy.linalg.eig(A)\n sys = sss(A,[[1],[0]],[0,1],0)\n pole = control.pole(sys)\n if numpy.real(pole[0]) != 0:\n p1r = abs(numpy.real(pole[0]))\n else:\n p1r = 1\n if numpy.real(pole[1]) != 0:\n p2r = abs(numpy.real(pole[1]))\n else:\n p2r = 1\n if numpy.imag(pole[0]) != 0:\n p1i = abs(numpy.imag(pole[0]))\n else:\n p1i = 1\n if numpy.imag(pole[1]) != 0:\n p2i = abs(numpy.imag(pole[1]))\n else:\n p2i = 1\n \n print('Svojstvene vrijednosti matrice A su:',round(sols[0][0],4),'i',round(sols[0][1],4))\n \n #T = numpy.linspace(0, 60, 1000)\n T, yout, xout = control.initial_response(sys,X0=X0,return_x=True)\n \n fig = plt.figure(\"Svojstvene vrijednosti od A\", figsize=(16,16))\n ax = fig.add_subplot(311,title='Polovi (Re vs Img)')\n #plt.axis(True)\n # Move left y-axis and bottim x-axis to centre, passing through (0,0)\n # Eliminate upper and right axes\n ax.spines['left'].set_position(('data',0.0))\n ax.spines['bottom'].set_position(('data',0.0))\n ax.spines['right'].set_color('none')\n ax.spines['top'].set_color('none')\n ax.set_xlim(-max([p1r+p1r/3,p2r+p2r/3]),\n max([p1r+p1r/3,p2r+p2r/3]))\n ax.set_ylim(-max([p1i+p1i/3,p2i+p2i/3]),\n max([p1i+p1i/3,p2i+p2i/3]))\n \n plt.plot([numpy.real(pole[0]),numpy.real(pole[1])],[numpy.imag(pole[0]),numpy.imag(pole[1])],'o')\n plt.grid()\n\n ax1 = fig.add_subplot(312,title='Slobodni odziv')\n plt.plot(T,xout[0])\n plt.grid()\n ax1.set_xlabel('vrijeme [s]')\n ax1.set_ylabel('$x_1$')\n ax1.axvline(x=0,color='black',linewidth='0.8')\n ax1.axhline(y=0,color='black',linewidth='0.8')\n ax2 = fig.add_subplot(313)\n plt.plot(T,xout[1])\n plt.grid()\n ax2.set_xlabel('vrijeme [s]')\n ax2.set_ylabel('$x_2$')\n ax2.axvline(x=0,color='black',linewidth='0.8')\n ax2.axhline(y=0,color='black',linewidth='0.8')\n \n #plt.show()\n \n\n \nalltogether = widgets.HBox([widgets.VBox([widgets.Label('$A$:',border=3),\n Aw]),\n widgets.Label(' ',border=3),\n widgets.VBox([widgets.Label('$X_0$:',border=3),\n X0w]),\n START])\nout = widgets.interactive_output(main_callback, {'A':Aw, 'X0':X0w, 'DW':DW})\nout.layout.height = '1000px'\ndisplay(out, alltogether)\n```\n\n\n Output(layout=Layout(height='1000px'))\n\n\n\n HBox(children=(VBox(children=(Label(value='$A$:'), matrixWidget(children=(HBox(children=(FloatText(value=0.0, …\n\n", "meta": {"hexsha": "507f92e31542dbbb7fde9b936afeb133fa05ba05", "size": 16192, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_hr/examples/04/SS-17-Unutarnja_stabilnost.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_hr/examples/04/SS-17-Unutarnja_stabilnost.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_hr/examples/04/SS-17-Unutarnja_stabilnost.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 39.6862745098, "max_line_length": 467, "alphanum_fraction": 0.5287796443, "converted": true, "num_tokens": 3475, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.25982564942392716, "lm_q1q2_score": 0.1238276173398482}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ntag = HTML('''\nPromijeni vidljivost ovdje .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n\n```\n\n\n\nPromijeni vidljivost ovdje .\n\n\n## Beskonačne točke ravnoteže 3\n\nOvaj interaktivni primjer prikazuje $2\\times2$ sustav koji ima beskonačno mnogo točaka ravnoteže koje leže na pravcu $x_1=-x_2$ (za podležeću teoriju pogledajte interaktivnu lekciju o točkama ravnoteže).\n\nDa bi pravac $x_1=-x_2$ bio prostor ravnotežnih točaka, treba vrijediti:\n$$\nA\\bar{x}=0 \\quad \\forall \\, \\bar{x}\\in\\begin{bmatrix} \\alpha \\\\ -\\alpha\\end{bmatrix} \\, \\text{uz} \\, \\alpha\\in\\mathbb{R},\n$$\nstoga, $\\begin{bmatrix} \\alpha \\\\ -\\alpha\\end{bmatrix}$ mora pripadati \"null-prostoru\" (engl. nullspace) matrice $A$.\n\n### Kako koristiti ovaj interaktivni primjer?\n- Izravno izmijenite matricu $A$ da biste vidjeli kako se mijenjaju točke ravnoteže.\n- Pokušajte modificirati $A$ na način da točke ravnoteže leže na zadanom skupu.\n\n\n```python\n#Preparatory Cell \n\nimport control\nimport numpy\nfrom IPython.display import display, Markdown\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\nimport sympy as sym\n\n#print a matrix latex-like\ndef bmatrix(a):\n \"\"\"Returns a LaTeX bmatrix - by Damir Arbula (ICCT project)\n\n :a: numpy array\n :returns: LaTeX bmatrix as a string\n \"\"\"\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{bmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{bmatrix}']\n return '\\n'.join(rv)\n\n\n# Display formatted matrix: \ndef vmatrix(a):\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{vmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{vmatrix}']\n return '\\n'.join(rv)\n\n\n#create a NxM matrix widget \ndef createMatrixWidget(n,m):\n M = widgets.GridBox(children=[widgets.FloatText(layout=widgets.Layout(width='100px', height='40px'),\n value=0.0, disabled=False, label=i) for i in range(n*m)],\n layout=widgets.Layout(\n #width='50%',\n grid_template_columns= ''.join(['100px ' for i in range(m)]),\n #grid_template_rows='80px 80px 80px',\n grid_row_gap='0px',\n track_size='0px')\n )\n return M\n\n\n#extract matrix from widgets and convert to numpy matrix\ndef getNumpyMatFromWidget(M,n,m):\n #get W gridbox dims\n M_ = numpy.matrix(numpy.zeros((n,m)))\n for irow in range(0,n):\n for icol in range(0,m):\n M_[irow,icol] = M.children[irow*3+icol].value\n\n \n#this is a simple derived class from FloatText used to experience with interact \nclass floatWidget(widgets.FloatText):\n def __init__(self,**kwargs):\n #self.n = n\n self.value = 30.0\n #self.M = \n widgets.FloatText.__init__(self, **kwargs)\n\n# def value(self):\n# return 0 #self.FloatText.value\n\nfrom traitlets import Unicode\nfrom ipywidgets import register \n\n\n#matrixWidget is a matrix looking widget built with a VBox of HBox(es) that returns a numPy array as value !\nclass matrixWidget(widgets.VBox):\n def updateM(self,change):\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.M_[irow,icol] = self.children[irow].children[icol].value\n #print(self.M_[irow,icol])\n self.value = self.M_\n\n def dummychangecallback(self,change):\n pass\n \n \n def __init__(self,n,m):\n self.n = n\n self.m = m\n self.M_ = numpy.matrix(numpy.zeros((self.n,self.m)))\n self.value = self.M_\n widgets.VBox.__init__(self,\n children = [\n widgets.HBox(children = \n [widgets.FloatText(value=0.0, layout=widgets.Layout(width='90px')) for i in range(m)]\n ) \n for j in range(n)\n ])\n \n #fill in widgets and tell interact to call updateM each time a children changes value\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n self.children[irow].children[icol].observe(self.updateM, names='value')\n #value = Unicode('example@example.com', help=\"The email value.\").tag(sync=True)\n self.observe(self.updateM, names='value', type= 'All')\n \n def setM(self, newM):\n #disable callbacks, change values, and reenable\n self.unobserve(self.updateM, names='value', type= 'All')\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].unobserve(self.updateM, names='value')\n self.M_ = newM\n self.value = self.M_\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].observe(self.updateM, names='value')\n self.observe(self.updateM, names='value', type= 'All') \n\n #self.children[irow].children[icol].observe(self.updateM, names='value')\n\n \n\n \n#overlaod class for state space systems that DO NOT remove \"useless\" states (what \"professor\" of automatic control would do this?)\nclass sss(control.StateSpace):\n def __init__(self,*args):\n #call base class init constructor\n control.StateSpace.__init__(self,*args)\n #disable function below in base class\n def _remove_useless_states(self):\n pass\n```\n\n\n```python\n#define the matrixes\nA=matrixWidget(2,2)\nA.setM(numpy.matrix('1. 0.; 0. 1.'))\n\ndef main_callback(matA,DW):\n \n As = sym.Matrix(matA)\n NAs = As.nullspace()\n \n t = numpy.linspace(-10,10,1000)\n if len(NAs) == 1:\n eq1 = [t[i]*numpy.matrix(NAs[0]) for i in range(0,len(t))]\n x1 = [eq1[i][0,0] for i in range(0,len(t))]\n x2 = [eq1[i][1,0] for i in range(0,len(t))]\n \n fig = plt.figure(figsize=(6,6))\n if len(NAs) == 0:\n plt.plot(0,0,'bo')\n if len(NAs) == 1:\n plt.plot(x1,x2)\n if len(NAs) == 2:\n plt.fill((-5,-5,5,5),(-5,5,5,-5),alpha=0.5)\n plt.xlim(left=-5,right=5)\n plt.ylim(top=5,bottom=-5)\n plt.grid()\n plt.xlabel('$x_1$')\n plt.ylabel('$x_2$')\n print('Osnova za A-nullspace (po retcima) je %s. \\nSvojstvene vrijednosti su %s' %(str(numpy.array(NAs)),\n str(numpy.linalg.eig(matA)[0])))\n\n\n#create dummy widget \nDW = widgets.FloatText(layout=widgets.Layout(width='0px', height='0px'))\n\n#create button widget\nSTART = widgets.Button(\n description='Test',\n disabled=False,\n button_style='', # 'success', 'info', 'warning', 'danger' or ''\n tooltip='Test',\n icon='check'\n)\n \ndef on_start_button_clicked(b):\n #This is a workaround to have intreactive_output call the callback:\n # force the value of the dummy widget to change\n if DW.value> 0 :\n DW.value = -1\n else: \n DW.value = 1\n pass\nSTART.on_click(on_start_button_clicked)\n\nout = widgets.interactive_output(main_callback,{'matA':A,'DW':DW})\nout1 = widgets.HBox([out,\n widgets.VBox([widgets.Label(''),widgets.Label(''),widgets.Label(''),widgets.Label('$\\qquad \\qquad A=$')]),\n widgets.VBox([widgets.Label(''),widgets.Label(''),widgets.Label(''),A,START])])\nout.layout.height = '450px'\ndisplay(out1)\n```\n\n\n HBox(children=(Output(layout=Layout(height='450px')), VBox(children=(Label(value=''), Label(value=''), Label(v…\n\n\n\n```python\n#create dummy widget 2\nDW2 = widgets.FloatText(layout=widgets.Layout(width='0px', height='0px'))\nDW2.value = -1\n\n#create button widget\nSTART2 = widgets.Button(\n description='Prikaži odgovore',\n disabled=False,\n button_style='', # 'success', 'info', 'warning', 'danger' or ''\n tooltip='Klikni za prikaz odgovora',\n icon='check'\n)\n \ndef on_start_button_clicked2(b):\n #This is a workaround to have intreactive_output call the callback:\n # force the value of the dummy widget to change\n if DW2.value> 0 :\n DW2.value = -1\n else: \n DW2.value = 1\n pass\nSTART2.on_click(on_start_button_clicked2)\n\ndef main_callback2(DW2):\n if DW2 > 0:\n display(Markdown(r'''Odgovor:\nZa konstrukciju matrice moguće je odabrati vektore redaka koji su ortogonalni u odnosu na nullspace. Moguća matrica je stoga:\n\n$$\nA=\\begin{bmatrix} 1 & 1 \\\\ 2 & 2 \\end{bmatrix}.\n$$'''))\n else:\n display(Markdown(''))\n\n#create a graphic structure to hold all widgets \nalltogether2 = widgets.VBox([START2])\n\nout2 = widgets.interactive_output(main_callback2,{'DW2':DW2})\n#out.layout.height = '300px'\ndisplay(out2,alltogether2)\n```\n\n\n Output()\n\n\n\n VBox(children=(Button(description='Prikaži odgovore', icon='check', style=ButtonStyle(), tooltip='Klikni za pr…\n\n", "meta": {"hexsha": "28476949329057dca16a48bcd7ab492b563ff998", "size": 14729, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_hr/examples/04/SS-16-Tocke_ravnoteze_primjer_3.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_hr/examples/04/SS-16-Tocke_ravnoteze_primjer_3.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_hr/examples/04/SS-16-Tocke_ravnoteze_primjer_3.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 35.8369829684, "max_line_length": 213, "alphanum_fraction": 0.5005091995, "converted": true, "num_tokens": 2680, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733885, "lm_q2_score": 0.2658804672827599, "lm_q1q2_score": 0.12360824703724588}}
{"text": "\n\n[1](#footnote1) of stellar nucleosynthesis that should produce some interesting visuals.\n\n\n\n\nFirst, we'll start with a with a generic atom, any old atom will do, and we'll specify and arbitrary number of neutrons $N$ and an arbitrary number of protons $Z$. Once the atom is specified, we're going to assume it is trapped inside the $r$ or $s$ process and then we will toss a coin as to whether or not it captures a neutron, or beta decays. If it captures a neutron we'll increase the neutron count by one, if not we'll beta decay and lose a neutron and gain a proton, outlined in the flowchart below\n\n>\n\n> The image above depicts the calculation process required in order to create our toy model of nucleosynthesis. The green box outlines the calculation process when protons are not allowed to decay, and the gray box outlines the process when protons are allowed to decay. To begin we have an initial number of neutrons $N$ and an initial number if protons $Z$. We then draw a random number $r$ uniformly from the range $[0,1]$, and compare that to our neutron capture probability $p_{NC}$. If $r$ is greater than the probability of neutron capture, we gain a neutron, if not, we beta decay thereby losing a neutron and gaining a proton. Alternatively, if we're allowing proton decay, if our random number has dictated that we beta decay, we then draw a second random number $r_2$ uniformly from $[0,1]$ and compare it to our probability of proton decay $p_{PD}$. This comparison then decides which mode of decay that our atom will undergo. We however note that the exit condition in the widget you'll soon see is slightly different preventing cases where reaching $Z/N > 1$ may take a long time, or is changed to $N/Z > 1$ if there are more protons than neutrons at the beginning of the simulation. \n\n\n-----\n\n1 : Here, toy model is understood to mean \"wrong; but informative\". \n\n## Visualization\n\n\nWith the figure below you can visualize a nuclide's pathway to becoming a heavy element. We do note however that while this simulation will give you a basic idea of the process, the model described here is _far_ from realistic. \n\n\n\n```python\n# This is the exit condition of our loop, scaled to the original number of neutrons and protons\ndef Condition(Z,N, Z_0, N_0):\n if Z_0 >= N_0:\n return N/Z\n if N_0 > Z_0:\n return Z/N\n# This is our toy model \ndef SimulateNewElement(N,Z, BetaNegative=False, ProbNegative = 0.1):\n # Initialize some lists and counters\n count = 0\n NArray = []\n ZArray = []\n min_iterations = 20\n N_0 = N\n Z_0 = Z\n # An infinite loop, relying on the break function to stop based on the conditions we've decided on\n while True:\n # Count how many times we've cycled and draw a random number\n count += 1\n r = random.uniform(0,1)\n # neutron capture\n if r >= 0.5:\n N = N + 1\n NArray.append(N)\n ZArray.append(Z)\n # beta decay\n elif r < 0.5:\n # draw a second random number to decide what kind of beta decay\n r2 = random.uniform(0,1)\n # Can only beta decay if we have a neutron and a proton\n if N > 0 and Z > 0:\n # If we're allowing proton decay\n if BetaNegative:\n # Beta minus decay\n if r2 < 1 - ProbNegative:\n N = N - 1 \n Z = Z + 1\n # beta plus decay\n else:\n N = N + 1\n Z = Z - 1\n else:\n # beta minus decay\n N = N - 1\n Z = Z + 1\n # save our counts at each iteration\n NArray.append(N)\n ZArray.append(Z)\n # Decide if we should leave\n if Condition(Z,N,Z_0,N_0) > 1.01 and count > min_iterations:\n if count > min_iterations:\n print(\"Reached Z = N line and passed minimum iterations, simulation finished\")\n else:\n print(\"Ran minimum number of times and passed Z=N line.\")\n break \n if count > 200:\n print(\"Taking too long, exiting early after 200 iterations\")\n print(\"Try lowering the probability of negative beta decay\")\n print(\"Or just simply running this simulation again\")\n break\n return np.array(NArray), np.array(ZArray), np.linspace(0,count,count)\ndef TwoDAnimation(N,Z,ProtonDecayAllowed = True, ProbabilityOfProtonDecay = 0.0):\n N,Z,count = SimulateNewElement(N,\n Z, \n BetaNegative=ProtonDecayAllowed, \n ProbNegative=ProbabilityOfProtonDecay)\n steps = []\n data1 = [dict(type='scatter', visible = False, name = \"Nuclide Path\",\n marker = dict(color = 'rgb(194,91,86)', line = dict( color = 'rgb(194,91,86)')),\n mode = 'markers+lines', x = N[0:step], y = Z[0:step]) for step in range(len(N))]\n LinePoints = np.linspace(min(Z[0],N[0]), max(N[-1],Z[-1]), len(N))\n data2 = [dict(type='scatter', visible = False, name = \"N = Z line\",\n marker = dict(color = 'rgb(190,185,191)', line = dict( color = 'rgb(190,185,191)')),\n mode = 'lines', x = LinePoints, y = LinePoints) for step in range(len(N))]\n data2[1]['visible'] = True\n data = data1 + data2 \n frames = data\n for i in range(len(data1)):\n step = dict(method = 'restyle', args = ['visible' ,[False] * len(data1)])\n step['args'][1][i] = True\n steps.append(step)\n sliders = [dict(active = 0, pad = {\"t\":50}, steps = steps,\n currentvalue = {'font': {'size': 20}, 'prefix': 'Nuclide:',\n 'visible': True, 'xanchor': 'right'},\n transition= {'duration': 300, 'easing': 'cubic-in-out'})]\n layout = dict(sliders=sliders, #updatemenus = updatemenus,\n title = \"Toy Model of Nucleosynthesis\",\n xaxis={\"title\":\"Number of Neutrons\"},\n yaxis = {\"title\":\"Number of Protons\"})\n fig = py.graph_objs.Figure(data=data, layout=layout)\n py.offline.iplot(fig) \nProtonList = [i for i in range(5,100)]\nNeutronList = [i for i in range(10, 105)]\ninteractive_plot2 = interactive(TwoDAnimation, Z=ProtonList, N=NeutronList, continuous_update=True)\ninteractive_plot2\n```\n\nIn the figure above you can use the drop down menus to adjust the number of neutrons $N$ and the number of protons $Z$. By clicking `ProtonDecayAllowed` (enabled by default), you are allowing your protons to decay, with probability as selected by the `Probability...` slider. You can then view the nucleon's path through nucleosynthesis with the slider on the bottom. Also note by clicking and dragging you can zoom in on any point of the plot to your liking. \n\n### Questions\n1. Which way does the nucleon move on the path for neutron capture? $\\beta^+$ decay? $\\beta^-$ decay? \n2. What does the path look like when you increase the probability of proton decay to fifty percent or more? Why? Be sure that `ProtonDecayAllowed` is clicked, and that you have at least 40 protons.\n\n### Conclusion\n\nIn conclusion we covered the idea of radioactive decay as well as several modes of decay. We covered the general formulas for alpha and both flavors of beta decay. Using these ideas, we created a model which simulated the counts we might actually observe in nuclear decay and compared them to the theoretical curve for many unstable elements. This showed us that while the theory may predict smooth and equal counts, actual observation may be a little messier. This simulation can be used as preparation for actual experiments and to help understand what you would observe.\n\nWe also introduced the idea of neutron capture and the origin of the heavy elements. In order to help understand how the heavy elements are created, we created a toy model similar to the decay of an atom, except this time we simulated how an atom may capture neutrons and beta decay in order to create a heavier element.\n\n[](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)\n", "meta": {"hexsha": "1715ad06305092b38ba789b8d03b981c926b54ce", "size": 40819, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Science/NuclearDecay/nuclear-decay.ipynb", "max_stars_repo_name": "callysto/curriculum-notebooks", "max_stars_repo_head_hexsha": "871241c8f318cff74f46f42705a03020cd48cd17", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 21, "max_stars_repo_stars_event_min_datetime": "2018-08-23T20:41:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-04-21T02:27:13.000Z", "max_issues_repo_path": "Science/NuclearDecay/nuclear-decay.ipynb", "max_issues_repo_name": "callysto/curriculum-notebooks", "max_issues_repo_head_hexsha": "871241c8f318cff74f46f42705a03020cd48cd17", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 113, "max_issues_repo_issues_event_min_datetime": "2018-07-23T21:05:00.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-16T23:40:08.000Z", "max_forks_repo_path": "Science/NuclearDecay/nuclear-decay.ipynb", "max_forks_repo_name": "callysto/curriculum-notebooks", "max_forks_repo_head_hexsha": "871241c8f318cff74f46f42705a03020cd48cd17", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 11, "max_forks_repo_forks_event_min_datetime": "2018-11-20T16:36:59.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-03T12:58:55.000Z", "avg_line_length": 67.1365131579, "max_line_length": 1207, "alphanum_fraction": 0.6337734878, "converted": true, "num_tokens": 8581, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.31405054499180746, "lm_q2_score": 0.3923368301671083, "lm_q1q2_score": 0.12321359533433857}}
{"text": "Table of Contents \n\n\n## Sound and simple vibrations\nIn the next 20 minutes, you will learn\n- What sound is and how it propagates\n- How humans perceive sound\n- What a sinusoid is\n- that striking a bar creates a sinusoidal sound\n\n### What is sound?\n\n\n```\nfrom IPython.display import display, YouTubeVideo, Image\nYouTubeVideo('GkNJvZINSEY')\n```\n\n\n\n\n\n\n\n\n\n\nSound is a **vibration** which travels through a medium as\n- **longitudinal** waves: gasses (e.g., air), liquids (e.g., water), and solids (e.g., concrete)\n- **transversal** sound waves: solids (e.g., concrete)\n\nThe **speed of sound** depends on the medium. \n\nIn air at room temperature, for example, it is approximately 343 m/s.\n\n\n```\nImage('apLecture1_files/wave.png')\n```\n\nSound is normally divided into three types:\n1. *Infrasound*: Sound with frequencies up to 20 Hz\n2. *Audible sound*: Sound with frequencies in range 20 Hz - 20 kHz (*audio*)\n3. *Ultrasound*: Sound with frequencies above 20 kHz\n\n\n### Human hearing\n\n\n```\nYouTubeVideo('eQEaiZ2j9oc') #2:27\n```\n\n\n\n\n\n\n\n\n\n\nThe human ear consists of the following parts:\n- **Outer ear**: Everything on the outside of the ear drum, including the pinna\n- **Middle ear**: The three bones (Malleus, Incus, Stapes). What do they do?\n- **Inner ear**: The cochlea (Latin for what?) tube. What does the basilar membrane do inside? Hair cells?\n\n\n \n\nThe human ear\n- does not hear all frequencies equally well\n- is most sensitive to frequencies around 4 kHz\n- is tuned to speech\n- has a really large dynamic range of up to ~120 dB (i.e., we can hear sound intensities up to ~10^12 the quietest sounds)\n\n\n \n\n### Sinusoids\nA sinusoid (or a sine wave) is given by\n$$\n x(t) = A \\cos(\\Omega t + \\Phi)\n$$\nwhere\n- $A\\geq0$ is the **amplitude**\n- $\\Omega$ is the **frequency** measured in radians pr. second (SI symbol **rad/s**). Is related to the frequency $f$ measured in cycles pr. second (SI symbol **Hz**) via $\\Omega = 2\\pi f$.\n- $t$ is the **time** measured in seconds (SI symbol **s**)\n- $\\Phi$ is the **initial phase** measured in radians (SI symbol **rad**)\n\nThe above form of the sinusoid is often referred to as the **polar form**. By using the angle addition formula for a cosine, i.e.,\n\n$$\n \\cos(\\theta+\\phi) = \\cos(\\theta)\\cos(\\phi)-\\sin(\\theta)\\sin(\\phi)\\ ,\n$$\n\na sinusoid can also be written in a **rectangular form** as\n\n$$\n x(t) = a\\cos(\\Omega t) + b\\sin(\\Omega t)\n$$\n\nwhere a and b are scalars given by\n\\begin{align}\n a &= A\\cos(\\Phi)\\\\\n b &= -A\\sin(\\Phi)\\ .\n\\end{align}\n\n#### Numpy example: A sinusoid\n\n\n```\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nsamplingFreq = 44100 # Hz\nnData = 2000\ntime = np.arange(0,nData).T/samplingFreq # s\n\n# Generate a sinusoid\namp = 1;\nfreq = 100 # Hz\ninitPhase = np.pi/2 # rad\nsinusoid = amp*np.cos(2*np.pi*freq*time+initPhase)\n \n# Plot the sinusoids\nplt.plot(time, sinusoid, linewidth=2)\nplt.xlim((time[0],time[nData-1]))\nplt.ylim((-1,1))\nplt.xlabel('Time [s]')\nplt.ylabel('Amplitude [.]')\nplt.grid(True)\n```\n\n#### Example: Generation of a sinusoid from a vibrating bar\n\n\n \n\nAssume that the act of striking a bar is modelled as **compressing a spring** in one dimension. \n\nFrom Hooke's law, this compresssion can be written as\n$$\n F(t) = -k x(t)\n$$\nwhere\n- $F(t)$ is the **restoring force** measured in Newton (SI unit **N**)\n- $x(t)$ is the **displacement** measured in meters (SI unit **m**) of the string from its resting position\n- $k$ is the **spring constant** measured in N/m\n\nFrom **Newton's second law**, the force can also be expressed as\n\n$$\n F(t) = ma(t)\n$$\n\nwhere\n- $m$ is the **mass** of the string measured in kilogram (SI unit **kg**)\n- $a(t)$ is the **acceleration** measured in m/s^2.\n\nThe acceleration is related to the displacement $x(t)$ as\n$$\n a(t) = \\frac{dv(t)}{dt} = \\frac{d^2 x(t)}{d t^2}\n$$\n\nwhere $v(t)$ is the **velocity** measured in m/s.\n\nCombining these three equations gives\n$$\n -k x(t) = F(t) = ma(t) = m \\frac{d^2 x(t)}{dt^2}\n$$\nwhich can be rewritten as\n$$\n \\frac{d^2 x(t)}{dt^2} = -\\frac{k}{m} x(t)\\ .\n$$\nThis is a constant-coefficient second-order differential equation.\n\nLet us check if our sinusoid\n$$\n x(t) = A\\cos(\\Omega t + \\Phi)\n$$\nis a solution to the above differential equation. Since\n\\begin{align}\n \\frac{dx(t)}{dt} &= -\\Omega A\\sin(\\Omega t + \\Phi)\\\\\n \\frac{d^2 x(t)}{d t^2} &= -\\Omega^2 A\\cos(\\Omega t + \\Phi) = -\\Omega^2 x(t)\\ ,\n\\end{align}\nwe obtain\n$$\n -\\Omega^2x(t) = -\\frac{k}{m} x(t)\\ .\n$$\nThus, striking a bar will make it vibrate sinusoidally with the frequency\n$$\n \\Omega = \\sqrt{k/m}\\ .\n$$\nThis frequency can be changed by changing the spring constant and mass.\n\n### Summary\n- Sound is a vibration travelling through a medium.\n- Sound waves are longitudal waves (and also transversal waves when travelling through a solid).\n- The human ear converts pressure variations in the air to\n 1. mechanical movement (interface is the eardrum)\n 2. vibrations in a liquid (interface is the oval window)\n 3. electrical signal to the brain (interface is the haircells attached to the basilar membrane)\n- A sinusoid (or sine wave) is given by\n$$\n x(t) = A\\cos(\\Omega t + \\Phi)\\ ,\n$$\nand it an extremely important building block (or atom) in analysing and manipulating sound.\n- Assuming that striking a bar can be modelled as compressing a spring, the bar will vibrate sinusoidally.\n\n## Complex numbers\nIn the next 20 minutes, you will learn\n- that the equation\n$$\n x^2+1=0\n$$\nhas two solutions\n- what a complex number is\n- how you add and multiply complex numbers\n\n### The need for complex numbers\nWhile the **linear** equation\n$$\n x + 1 = 0\n$$\ncan easily be solved, the simple **quadratic** equation\n$$\n x^2 + 1 = 0\n$$\nwas in high school said to have **no** solution since its descriminant was negative.\n\n\n```\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nnData = 100\nx = np.linspace(-2,2,nData)\ny = x**2+1\nplt.plot(x,y,linewidth=2)\nplt.xlabel('x')\nplt.ylabel('y')\nplt.ylim((-1,5))\nplt.grid(True);\n```\n\nHowever, the quadratic equation can in fact be solved by using **complex numbers**.\n\n\n```\nYouTubeVideo('T647CGsuOVU') #5:47\n```\n\n\n\n\n\n\n\n\n\n\nRearranging our simple **quadratic** equation gives\n$$\n x^2 = -1\n$$\nwhich allows us to write the solution as\n$$\n x = \\pm\\sqrt{-1} = \\pm j\n$$\nwhere\n$$\n j = \\sqrt{-1}\n$$\nis the **imaginary unit**. This unit also satisfies that\n$$\n j^2 = \\sqrt{-1}^2 = -1\\ .\n$$\n\nNote that\n- **engineers** normally use the symbol $j$ for the imaginary unit\n- **mathematicians** normally use the symbol $i$ for the imaginary unit.\n\nLet us now consider the quadratic equation\n$$\n x^2 + 2x + 5 = 0\\ .\n$$\n\nWe know from high school that the solutions to the general quadratic\n$$\n ax^2 + bx + c = 0\\ ,\\qquad\\text{for }a\\neq0\n$$\nhave the form\n$$\n x = \\frac{-b\\pm\\sqrt{d}}{2a}\n$$\nwhere $d$ is the **discriminant** given by\n$$\n d = b^2-4ac\\ .\n$$\n\nWe obtain\n$$\n d = 4-20 = -16\n$$\nso that\n$$\n x = \\frac{-2\\pm\\sqrt{-16}}{2} = -1\\pm\\frac{1}{2}\\sqrt{-1\\cdot 4^2} = -1\\pm 2\\sqrt{-1} = -1\\pm 2j\\ .\n$$\nThus, the **complex numbers** $-1+2j$ and $-1-2j$ are the solutions.\n\n### The complex number\nA **complex number** can be written as\n$$\n z = a + jb\n$$\nwhere\n- $a = \\text{Re}\\{z\\}$ is the **real** part\n- $b = \\text{Im}\\{z\\}$ is the **imaginary** part.\n\nA complex number can be depicted in the **complex plane** which is a 2D coordinate system.\n\n\n \n\n\n#### The complex conjugate\nThe **complex conjugate** of a complex number $z$ is\n$$\n z^* = a - jb\\ .\n$$\nThus, the conjugation operator ${}^*$ changes the sign of imaginary part, but not the real part.\n\n#### Addition of complex numbers\nAssume we have the two complex numbers\n\\begin{align}\n z_1 &= a_1+jb_1\\\\\n z_2 &= a_2+jb_2\\ .\n\\end{align}\n\nThe **sum** of these two numbers is then\n$$\n z = z_1 + z_2 = a_1+jb_1 + a_2+jb_2 = (a_1+a_2) + j(b_1+b_2).\n$$\n\nThus, the real and imaginary part of of $z=a+jb$ are simply\n\\begin{align}\n a &= a_1 + a_2\\\\\n b &= b_1 + b_2\\ .\n\\end{align}\n\nNote that\n\\begin{align}\n z_1 + z_1^* &= 2a_1 + 0j = 2\\text{Re}(z_1)\\\\\n z_1 - z_1^* &= 0 + 2jb_1 = 2\\text{Im}(z_1)\\ .\n\\end{align}\n\n\n\n#### Multiplication of complex numbers\nAssume we have the two complex numbers\n\\begin{align}\n z_1 &= a_1+jb_1\\\\\n z_2 &= a_2+jb_2\\ .\n\\end{align}\n\nThe **product** of these two numbers is then\n$$\n z = z_1z_2 = (a_1+jb_1)(a_2+jb_2) = (a_1a_2-b_1b_2) + j(a_1b_2+b_1a_2).\n$$\n\nThus, the real and imaginary part of of $z=a+jb$ are\n\\begin{align}\n a &= (a_1a_2-b_1b_2)\\\\\n b &= (a_1b_2+b_1a_2)\\ .\n\\end{align}\n\nNote that\n$$\n z_1z_1^* = (a_1a_1-b_1(-b_1)) +j(a_1b_1-b_1a_1) = a_1^2+b_1^2 = \\text{Re}(z_1)^2+\\text{Im}(z_1)^2\n$$\n\n### Summary\n- Complex numbers were originally invented to solve algebraic equations (e.g., the cubic equation)\n- The imaginary unit is $j=\\sqrt{-1}$\n- A **complex number** $z$ consists of a real part $a$ and imaginary part $b$, and is written as\n$$\n z = a+jb\\ .\n$$\n- The **complex conjugate** of $z$ is\n$$\n z^* = a-jb\\ .\n$$\n- It is much easier to add two complex numbers than it is to multiply them.\n\n### Additional information on complex numbers\nIf you want to know more about complex numbers (e.g., its history), you can find some nice videos here:\n\nhttps://www.youtube.com/playlist?list=PLiaHhY2iBX9g6KIvZ_703G3KJXapKkNaF\n\n### Exit Question\nLet\n\\begin{align}\n z_1 &= a_1+jb_1 = 2+3j\\\\\n z_2 &= a_2+jb_2 = -1-2j\\ .\n\\end{align}\n\nBy hand, please calculate\n\\begin{align}\n z_1 + z_2 &= \\\\\n z_1 - z_2 &= \\\\\n z_1 + z_1^* &= \\\\\n z_2 - z_2^*+2z_1 &= \\\\\n z_1z_2^* &=\\\\\n z_1^2+z_2^*z_1 &=\n\\end{align}\nCheck the results with your neighbours.\n\n---\n**Tip:** Use the rules\n\\begin{align}\n z_1 + z_2 &= (a_1+a_2) + j(b_1+b_2)\\\\\n z_1z_2 &= (a_1a_2-b_1b_2) + j(a_1b_2+b_1a_2)\\ .\n\\end{align}\n\n## Phasors\nIn the next 20 minutes, you will learn\n- how a complex number can be written in a **polar form**\n- why the polar form makes multiplications much easier\n- what a **phasor** is\n- how a phasor is related to a **real sinusoid**\n\n### The polar (or exponential) form of a complex number\nAs for 2D vectors, we can also write a complex number in terms of its **magnitude** $r$ and **angle** $\\psi$. We have\n\\begin{align}\n a &= r\\cos\\psi\\\\\n b &= r\\sin\\psi\\ .\n\\end{align}\nThus,\n$$\n z = a + jb = r\\left(\\cos\\psi + j\\sin\\psi\\right) = r\\mathrm{e}^{j\\psi}\n$$\nwhere the last equality follows from **Euler's formula**.\n\n\n \n\n#### Euler's formula\nGiven by\n$$\n \\mathrm{e}^{j\\psi} = \\cos\\psi + j\\sin\\psi\\ .\n$$\n- A very important formula used everywhere in science and engineering\n- Simplifies notation and mathematical manipulations\n- Its real and imaginary parts are a cosine and a sine, respectively, i.e.,\n\\begin{align}\n \\text{Re}(\\mathrm{e}^{j\\psi}) &= \\cos\\psi\\\\\n \\text{Im}(\\mathrm{e}^{j\\psi}) &= \\sin\\psi\\ .\n\\end{align}\n\n\n \n\n#### The complex conjugate\nThe **complex conjugate** of a complex number\n$$\n z=r \\mathrm{e}^{j\\psi}\n$$\nis\n$$\n z^* = r \\mathrm{e}^{-j\\psi}\\ .\n$$\nThus, the conjugation operator ${}^*$ changes the sign of the angle, but not the magnitude.\n\n#### Multiplication of complex numbers\nMultiplication of complex numbers is much easier when the polar form is used. Let\n\\begin{align}\n z_1 &= a_1+jb_1 = r_1 \\mathrm{e}^{j\\psi_1}\\\\\n z_2 &= a_2+jb_2 = r_2 \\mathrm{e}^{j\\psi_2}\\ .\n\\end{align}\n\nThe **product** of these two numbers is then\n$$\n z = z_1z_2 = r_1 \\mathrm{e}^{j\\psi_1}r_2 \\mathrm{e}^{j\\psi_2} = r_1 r_2 \\mathrm{e}^{j\\psi_1}r_2 \\mathrm{e}^{j\\psi_2} = r_1 r_2 \\mathrm{e}^{j(\\psi_1+\\psi_2)}\n$$\nwhere we used $a^na^m = a^{n+m}$ to get the last equation.\n\nThus, to multiply two complex numbers we\n- multiply their magnitudes\n- add their angles\n\nNote that **divisions** can be calculated as multiplications since\n$$\n \\frac{z_1}{z_2} = z_1\\frac{1}{z_2} = z_1 z_2^{-1}\n$$\nand\n$$\n z_2^{-1} = \\frac{1}{r_2}\\mathrm{e}^{-j\\psi_2}\\ .\n$$\n\n#### Converting between the rectangular and polar forms\nWe have seen that a complex number $z$ can be written as\n$$\n z = a+jb = r\\mathrm{e}^{j\\psi}\\ .\n$$\n\nWe can convert from the polar coordinates $(r,\\psi)$ to the rectangular coordinates $(a,b)$ via\n\\begin{align}\n a &= r\\cos\\psi\\\\\n b &= r\\sin\\psi\\ .\n\\end{align}\n\nWe can convert from the rectangular coordinates $(a,b)$ to the polar coordinates $(r,\\psi)$ via\n\\begin{align}\n r &= \\sqrt{a^2+b^2}\\\\\n \\psi &= \\mathrm{arctan2}(b,a)\\ .\n\\end{align}\n\n### The phasor\nWe have previously looked at the sinusoid\n$$\n x(t) = A\\cos(\\Omega t + \\Phi)\\ .\n$$\n\nBased on what we know about Euler's formula and complex numbers, we can now also write $x(t)$ as\n$$\n x(t) = \\text{Re}\\left[A\\exp(j(\\Omega t +\\Psi))\\right]\n$$\nsince (from Euler's formula)\n$$\n A\\exp(j(\\Omega t +\\Psi)) = A\\cos(\\Omega t +\\Psi)+jA\\sin(\\Omega t +\\Psi)\\ .\n$$\nThis time-varying complex number is called a **phasor** or a **complex sinusoid**.\n\nNote that\n- using the phasor instead of the real sinusoid makes life much easier (you will see this later in the course)\n- even though we work with the phasor, we can always come back to the real sinusoid by taking the real part of the phasor\n\n\n\n \n\n\n\n \n\n### Summary\n- The **polar form** of a complex number $z=a+jb$ is\n$$\n z = r\\mathrm{e}^{j\\psi}\n$$\nwhere the magnitude $r$ and angle $\\psi$ are given by\n\\begin{align}\n r &= \\sqrt{a^2+b^2}\\\\\n \\psi &= \\mathrm{arctan2}(b,a)\\ .\n\\end{align}\n- Multiplications (and divisions) are much easier when using the polar form.\n- A **phasor** is a complex sinusoid given by\n$$\n z(t) = A\\exp(j(\\Omega t +\\Psi))\\ ,\n$$\nand its real part is a real sinusoid, i.e., \n$$\n x(t) = \\text{Re}(z(t)) = A\\cos(\\Omega t +\\Psi)\\ .\n$$\n\n", "meta": {"hexsha": "ca3817aa777496cca1a300ef20082aa933130236", "size": 215974, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lecture1_What_is_Sound/apLecture1.ipynb", "max_stars_repo_name": "SMC-AAU-CPH/med4-ap-jupyter", "max_stars_repo_head_hexsha": "398fbb0bd06a879127ab020d7dc09121c2c67822", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-03T08:38:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-10T04:26:04.000Z", "max_issues_repo_path": "lecture1_What_is_Sound/apLecture1.ipynb", "max_issues_repo_name": "SMC-AAU-CPH/med4-ap-jupyter", "max_issues_repo_head_hexsha": "398fbb0bd06a879127ab020d7dc09121c2c67822", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-02-10T21:54:02.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-18T21:00:48.000Z", "max_forks_repo_path": "lecture1_What_is_Sound/apLecture1.ipynb", "max_forks_repo_name": "SMC-AAU-CPH/med4-ap-jupyter", "max_forks_repo_head_hexsha": "398fbb0bd06a879127ab020d7dc09121c2c67822", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-02-04T12:39:01.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-01T02:40:10.000Z", "avg_line_length": 196.34, "max_line_length": 67678, "alphanum_fraction": 0.8825228963, "converted": true, "num_tokens": 5630, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.24798741512455283, "lm_q1q2_score": 0.12302502642973404}}
{"text": "```python\nfrom mayavi import mlab\nmlab.init_notebook()\nmlab.test_plot3d()\n```\n\n Notebook initialized with ipy backend.\n\n\n\n Image(value=b'\\x89PNG\\r\\n\\x1a\\n\\x00\\x00\\x00\\rIHDR\\x00\\x00\\x01\\x90\\x00\\x00\\x01^\\x08\\x02\\x00\\x00\\x00$?\\xde_\\x00\\…\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n# Applications of vibration models\n
\n\nThe following text derives some of the most well-known physical\nproblems that lead to second-order ODE models of the type addressed in\nthis ${DOCUMENT}. We consider a simple spring-mass system; thereafter\nextended with nonlinear spring, damping, and external excitation; a\nspring-mass system with sliding friction; a simple and a physical\n(classical) pendulum; and an elastic pendulum.\n\n## Oscillating mass attached to a spring\n
\n\n\n\n
\n\nSimple oscillating mass.
\n\n\n\n\n\nThe most fundamental mechanical vibration system is depicted in [Figure](#vib:app:mass_spring:fig). A body with mass $m$ is attached to a\nspring and can move horizontally without friction (in the wheels). The\nposition of the body is given by the vector $\\rpos(t) = u(t)\\ii$, where\n$\\ii$ is a unit vector in $x$ direction.\nThere is\nonly one force acting on the body: a spring force $\\F_s =-ku\\ii$, where\n$k$ is a constant. The point $x=0$, where $u=0$, must therefore\ncorrespond to the body's position\nwhere the spring is neither extended nor compressed, so the force\nvanishes.\n\nThe basic physical principle that governs the motion of the body is\nNewton's second law of motion: $\\F=m\\acc$, where\n$\\F$ is the sum of forces on the body, $m$ is its mass, and $\\acc=\\ddot\\rpos$\nis the acceleration. We use the dot for differentiation with respect\nto time, which is\nusual in mechanics. Newton's second law simplifies here\nto $-\\F_s=m\\ddot u\\ii$, which translates to\n\n$$\n-ku = m\\ddot u\\thinspace .\n$$\n\nTwo initial conditions are needed: $u(0)=I$, $\\dot u(0)=V$.\nThe ODE problem is normally written as\n\n\n
\n\n$$\n\\begin{equation}\nm\\ddot u + ku = 0,\\quad u(0)=I,\\ \\dot u(0)=V\\thinspace .\n\\label{vib:app:mass_spring:eqx} \\tag{1}\n\\end{equation}\n$$\n\nmathcal{I}_t is\nnot uncommon to divide by $m$\nand introduce the frequency $\\omega = \\sqrt{k/m}$:\n\n\n
\n\n$$\n\\begin{equation}\n\\ddot u + \\omega^2 u = 0,\\quad u(0)=I,\\ \\dot u(0)=V\\thinspace .\n\\label{vib:app:mass_spring:equ} \\tag{2}\n\\end{equation}\n$$\n\nThis is the model problem in the first part of this chapter, with the\nsmall difference that we write the time derivative of $u$ with a dot\nabove, while we used $u^{\\prime}$ and $u^{\\prime\\prime}$ in previous\nparts of the ${DOCUMENT}.\n\n\nSince only one scalar mathematical quantity, $u(t)$, describes the\ncomplete motion, we say that the mechanical system has one degree of freedom\n(DOF).\n\n### Scaling\n\nFor numerical simulations it is very convenient to scale\n([2](#vib:app:mass_spring:equ)) and thereby get rid of the problem of\nfinding relevant values for all the parameters $m$, $k$, $I$, and $V$.\nSince the amplitude of the oscillations are dictated by $I$ and $V$\n(or more precisely, $V/\\omega$), we scale $u$ by $I$ (or $V/\\omega$ if\n$I=0$):\n\n$$\n\\bar u = \\frac{u}{I},\\quad \\bar t = \\frac{t}{t_c}\\thinspace .\n$$\n\nThe time scale $t_c$ is normally chosen as the inverse period $2\\pi/\\omega$ or\nangular frequency $1/\\omega$, most often as $t_c=1/\\omega$.\nInserting the dimensionless quantities $\\bar u$ and $\\bar t$ in\n([2](#vib:app:mass_spring:equ)) results in the scaled problem\n\n$$\n\\frac{d^2\\bar u}{d\\bar t^2} + \\bar u = 0,\\quad \\bar u(0)=1,\\ \\frac{\\bar u}{\\bar t}(0)=\\beta = \\frac{V}{I\\omega},\n$$\n\nwhere $\\beta$ is a dimensionless number. Any motion that starts from rest\n($V=0$) is free of parameters in the scaled model!\n\n### The physics\n\nThe typical physics of the system in [Figure](#vib:app:mass_spring:fig) can be described as follows. Initially,\nwe displace the body to some position $I$, say at rest ($V=0$). After\nreleasing the body, the spring, which is extended, will act with a\nforce $-kI\\ii$ and pull the body to the left. This force causes an\nacceleration and therefore increases velocity. The body passes the\npoint $x=0$, where $u=0$, and the spring will then be compressed and\nact with a force $kx\\ii$ against the motion and cause retardation. At\nsome point, the motion stops and the velocity is zero, before the\nspring force $kx\\ii$ has worked long enough to push the body in\npositive direction. The result is that the body accelerates back and\nforth. As long as there is no friction forces to damp the motion, the\noscillations will continue forever.\n\n## General mechanical vibrating system\n
\n\n\n\n
\n\nGeneral oscillating system.
\n\n\n\n\n\nThe mechanical system in [Figure](#vib:app:mass_spring:fig) can easily be\nextended to the more general system in [Figure](#vib:app:mass_gen:fig),\nwhere the body is attached to a spring and a dashpot, and also subject\nto an environmental force $F(t)\\ii$. The system has still only one\ndegree of freedom since the body can only move back and forth parallel to\nthe $x$ axis. The spring force was linear, $\\F_s=-ku\\ii$,\nin the section [Oscillating mass attached to a spring](#vib:app:mass_spring), but in more general cases it can\ndepend nonlinearly on the position. We therefore set $\\F_s=s(u)\\ii$.\nThe dashpot, which acts\nas a damper, results in a force $\\F_d$ that depends on the body's\nvelocity $\\dot u$ and that always acts against the motion.\nThe mathematical model of the force is written $\\F_d =f(\\dot u)\\ii$.\nA positive $\\dot u$ must result in a force acting in the positive $x$\ndirection.\nFinally, we have the external environmental force $\\F_e = F(t)\\ii$.\n\nNewton's second law of motion now involves three forces:\n\n$$\nF(t)\\ii - f(\\dot u)\\ii - s(u)\\ii = m\\ddot u \\ii\\thinspace .\n$$\n\nThe common mathematical form of the ODE problem is\n\n\n
\n\n$$\n\\begin{equation}\nm\\ddot u + f(\\dot u) + s(u) = F(t),\\quad u(0)=I,\\ \\dot u(0)=V\\thinspace .\n\\label{vib:app:mass_gen:equ} \\tag{3}\n\\end{equation}\n$$\n\nThis is the generalized problem treated in the last part of the\npresent chapter, but with prime denoting the derivative instead of the dot.\n\nThe most common models for the spring and dashpot are linear: $f(\\dot u)\n=b\\dot u$ with a constant $b\\geq 0$, and $s(u)=ku$ for a constant $k$.\n\n### Scaling\n\nA specific scaling requires specific choices of $f$, $s$, and $F$.\nSuppose we have\n\n$$\nf(\\dot u) = b|\\dot u|\\dot u,\\quad s(u)=ku,\\quad F(t)=A\\sin(\\phi t)\\thinspace .\n$$\n\nWe introduce dimensionless variables as usual, $\\bar u = u/u_c$ and\n$\\bar t = t/t_c$. The scale $u_c$ depends both on the initial conditions\nand $F$, but as time grows, the effect of the initial conditions die out\nand $F$ will drive the motion. Inserting $\\bar u$ and $\\bar t$ in the\nODE gives\n\n$$\nm\\frac{u_c}{t_c^2}\\frac{d^2\\bar u}{d\\bar t^2}\n+ b\\frac{u_c^2}{t_c^2}\\left\\vert\\frac{d\\bar u}{d\\bar t}\\right\\vert\n\\frac{d\\bar u}{d\\bar t} + ku_c\\bar u = A\\sin(\\phi t_c\\bar t)\\thinspace .\n$$\n\nWe divide by $u_c/t_c^2$ and demand the coefficients of the\n$\\bar u$ and the forcing term from $F(t)$ to have unit coefficients.\nThis leads to the scales\n\n$$\nt_c = \\sqrt{\\frac{m}{k}},\\quad u_c = \\frac{A}{k}\\thinspace .\n$$\n\nThe scaled ODE becomes\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d^2\\bar u}{d\\bar t^2}\n+ 2\\beta\\left\\vert\\frac{d\\bar u}{d\\bar t}\\right\\vert\n\\frac{d\\bar u}{d\\bar t} + \\bar u = \\sin(\\gamma\\bar t),\n\\label{vib:app:mass_gen:scaled} \\tag{4}\n\\end{equation}\n$$\n\nwhere there are two dimensionless numbers:\n\n$$\n\\beta = \\frac{Ab}{2mk},\\quad\\gamma =\\phi\\sqrt{\\frac{m}{k}}\\thinspace .\n$$\n\nThe $\\beta$ number measures the size of the damping term (relative to unity)\nand is assumed to be small, basically because $b$ is small. The $\\phi$\nnumber is the ratio of the time scale of free vibrations and the time scale\nof the forcing.\nThe scaled initial conditions have two other dimensionless numbers\nas values:\n\n$$\n\\bar u(0) = \\frac{Ik}{A},\\quad \\frac{d\\bar u}{d\\bar t}=\\frac{t_c}{u_c}V = \\frac{V}{A}\\sqrt{mk}\\thinspace .\n$$\n\n## A sliding mass attached to a spring\n
\n\nConsider a variant of the oscillating body in the section [Oscillating mass attached to a spring](#vib:app:mass_spring)\nand [Figure](#vib:app:mass_spring:fig): the body rests on a flat\nsurface, and there is sliding friction between the body and the surface.\n[Figure](#vib:app:mass_sliding:fig) depicts the problem.\n\n\n\n
\n\nSketch of a body sliding on a surface.
\n\n\n\n\n\nThe body is attached to a spring with spring force $-s(u)\\ii$.\nThe friction force is proportional to the normal force on the surface,\n$-mg\\jj$, and given by $-f(\\dot u)\\ii$, where\n\n$$\nf(\\dot u) = \\left\\lbrace\\begin{array}{ll}\n-\\mu mg,& \\dot u < 0,\\\\ \n\\mu mg, & \\dot u > 0,\\\\ \n0, & \\dot u=0\n\\end{array}\\right.\n$$\n\nHere, $\\mu$ is a friction coefficient. With the signum function\n\n$$\n\\mbox{sign(x)} = \\left\\lbrace\\begin{array}{ll}\n-1,& x < 0,\\\\ \n1, & x > 0,\\\\ \n0, & x=0\n\\end{array}\\right.\n$$\n\nwe can simply write $f(\\dot u) = \\mu mg\\,\\hbox{sign}(\\dot u)$\n(the sign function is implemented by `numpy.sign`).\n\nThe equation of motion becomes\n\n\n
\n\n$$\n\\begin{equation}\nm\\ddot u + \\mu mg\\hbox{sign}(\\dot u) + s(u) = 0,\\quad u(0)=I,\\ \\dot u(0)=V\\thinspace .\n\\label{vib:app:mass_sliding:equ} \\tag{5}\n\\end{equation}\n$$\n\n## A jumping washing machine\n
\n\nA washing machine is placed on four springs with efficient dampers.\nIf the machine contains just a few clothes, the circular motion of\nthe machine induces a sinusoidal external force from the floor and the machine will\njump up and down if the frequency of the external force is close to\nthe natural frequency of the machine and its spring-damper system.\n\n[hpl 1: Not finished. This is a good example on resonance.]\n\n\n\n## Motion of a pendulum\n
\n\n### Simple pendulum\n\nA classical problem in mechanics is the motion of a pendulum. We first\nconsider a [simplified pendulum](https://en.wikipedia.org/wiki/Pendulum) (sometimes also called a\nmathematical pendulum): a small body of mass $m$ is\nattached to a massless wire and can oscillate back and forth in the\ngravity field. [Figure](#vib:app:pendulum:fig_problem) shows a sketch\nof the problem.\n\n\n\n
\n\nSketch of a simple pendulum.
\n\n\n\n\n\nThe motion is governed by Newton's 2nd law, so we need to find\nexpressions for the forces and the acceleration. Three forces on the\nbody are considered: an unknown force $S$ from the wire, the gravity\nforce $mg$, and an air resistance force, $\\frac{1}{2}C_D\\varrho A|v|v$,\nhereafter called the drag force, directed against the velocity\nof the body. Here, $C_D$ is a drag coefficient, $\\varrho$ is the\ndensity of air, $A$ is the cross section area of the body, and $v$ is\nthe magnitude of the velocity.\n\nWe introduce a coordinate system with polar coordinates and unit\nvectors $\\ir$ and $\\ith$ as shown in [Figure](#vib:app:pendulum:fig_forces). The position of the center of mass\nof the body is\n\n$$\n\\rpos(t) = x_0\\ii + y_0\\jj + L\\ir,\n$$\n\nwhere $\\ii$ and $\\jj$ are unit vectors in the corresponding Cartesian\ncoordinate system in the $x$ and $y$ directions, respectively. We have\nthat $\\ir = \\cos\\theta\\ii +\\sin\\theta\\jj$.\n\n\n\n
\n\nForces acting on a simple pendulum.
\n\n\n\n\n\nThe forces are now expressed as follows.\n\n * Wire force: $-S\\ir$\n\n * Gravity force: $-mg\\jj = mg(-\\sin\\theta\\,\\ith + \\cos\\theta\\,\\ir)$\n\n * Drag force: $-\\frac{1}{2}C_D\\varrho A |v|v\\,\\ith$\n\nSince a positive velocity means movement in the direction of $\\ith$,\nthe drag force must be directed along $-\\ith$ so it works against the\nmotion. We assume motion in air so that the added mass effect can\nbe neglected (for a spherical body, the added mass is $\\frac{1}{2}\\varrho V$,\nwhere $V$ is the volume of the body). Also the buoyancy effect\ncan be neglected for motion in the air when the density difference\nbetween the fluid and the body is so significant.\n\nThe velocity of the body is found from $\\rpos$:\n\n$$\n\\v(t) = \\dot\\rpos (t) = \\frac{d}{d\\theta}(x_0\\ii + y_0\\jj + L\\ir)\\frac{d\\theta}{dt} = L\\dot\\theta\\ith,\n$$\n\nsince $\\frac{d}{d\\theta}\\ir = \\ith$. mathcal{I}_t follows that $v=|\\v|=L\\dot\\theta$.\nThe acceleration is\n\n$$\n\\acc(t) = \\dot\\v(r) = \\frac{d}{dt}(L\\dot\\theta\\ith)\n= L\\ddot\\theta\\ith + L\\dot\\theta\\frac{d\\ith}{d\\theta}\\dot\\theta =\n= L\\ddot\\theta\\ith - L\\dot\\theta^2\\ir,\n$$\n\nsince $\\frac{d}{d\\theta}\\ith = -\\ir$.\n\nNewton's 2nd law of motion becomes\n\n$$\n-S\\ir + mg(-\\sin\\theta\\,\\ith + \\cos\\theta\\,\\ir) -\n\\frac{1}{2}C_D\\varrho AL^2|\\dot\\theta|\\dot\\theta\\,\\ith\n= mL\\ddot\\theta\\dot\\theta\\,\\ith - L\\dot\\theta^2\\ir,\n$$\n\nleading to two component equations\n\n\n
\n\n$$\n\\begin{equation}\n-S + mg\\cos\\theta = -L\\dot\\theta^2,\n\\label{vib:app:pendulum:ir} \\tag{6}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n-mg\\sin\\theta - \\frac{1}{2}C_D\\varrho AL^2|\\dot\\theta|\\dot\\theta\n= mL\\ddot\\theta\\thinspace .\n\\label{vib:app:pendulum:ith} \\tag{7}\n\\end{equation}\n$$\n\nFrom ([6](#vib:app:pendulum:ir)) we get an expression for\n$S=mg\\cos\\theta + L\\dot\\theta^2$, and from ([7](#vib:app:pendulum:ith))\nwe get a differential equation for the angle $\\theta(t)$. This latter\nequation is ordered as\n\n\n
\n\n$$\n\\begin{equation}\nm\\ddot\\theta + \\frac{1}{2}C_D\\varrho AL|\\dot\\theta|\\dot\\theta\n+ \\frac{mg}{L}\\sin\\theta = 0\\thinspace .\n\\label{vib:app:pendulum:thetaeq} \\tag{8}\n\\end{equation}\n$$\n\nTwo initial conditions are needed: $\\theta=\\Theta$ and $\\dot\\theta = \\Omega$.\nNormally, the pendulum motion is started from rest, which means $\\Omega =0$.\n\nEquation ([8](#vib:app:pendulum:thetaeq)) fits the general model\nused in ([vib:ode2](#vib:ode2)) in the section [vib:model2](#vib:model2) if we define\n$u=\\theta$, $f(u^{\\prime}) = \\frac{1}{2}C_D\\varrho AL|\\dot u|\\dot u$,\n$s(u) = L^{-1}mg\\sin u$, and $F=0$.\nIf the body is a sphere with radius $R$, we can take $C_D=0.4$ and $A=\\pi R^2$.\n[Exercise 4: Simulate a simple pendulum](#vib:exer:pendulum_simple) asks you to scale the equations\nand carry out specific simulations with this model.\n\n### Physical pendulum\n\nThe motion of a compound or physical pendulum where the wire is a rod with\nmass, can be modeled very similarly. The governing equation is\n$I\\acc = \\boldsymbol{T}$ where $I$ is the moment of inertia of the entire body about\nthe point $(x_0,y_0)$, and $\\boldsymbol{T}$ is the sum of moments of the forces\nwith respect to $(x_0,y_0)$. The vector equation reads\n\n$$\n\\rpos\\times(-S\\ir + mg(-\\sin\\theta\\ith + \\cos\\theta\\ir) -\n\\frac{1}{2}C_D\\varrho AL^2|\\dot\\theta|\\dot\\theta\\ith)\n= I(L\\ddot\\theta\\dot\\theta\\ith - L\\dot\\theta^2\\ir)\\thinspace .\n$$\n\nThe component equation in $\\ith$ direction gives the equation of motion\nfor $\\theta(t)$:\n\n\n
\n\n$$\n\\begin{equation}\nI\\ddot\\theta + \\frac{1}{2}C_D\\varrho AL^3|\\dot\\theta|\\dot\\theta\n+ mgL\\sin\\theta = 0\\thinspace .\n\\label{vib:app:pendulum:thetaeq_physical} \\tag{9}\n\\end{equation}\n$$\n\n## Dynamic free body diagram during pendulum motion\n
\n\n\nUsually one plots the mathematical quantities as functions of time to\nvisualize the solution of ODE models. [Exercise 4: Simulate a simple pendulum](#vib:exer:pendulum_simple) asks you to do this for the motion of a\npendulum in the previous section. However, sometimes it is more\ninstructive to look at other types of visualizations. For example, we\nhave the pendulum and the free body diagram in Figures\n[vib:app:pendulum:fig_problem](#vib:app:pendulum:fig_problem) and\n[vib:app:pendulum:fig_forces](#vib:app:pendulum:fig_forces). We may think of these figures as\nanimations in time instead. Especially the free body diagram will show both the\nmotion of the pendulum *and* the size of the forces during the motion.\nThe present section exemplifies how to make such a dynamic body\ndiagram.\n% if FORMAT == 'pdflatex':\nTwo typical snapshots of free body diagrams are displayed below\n(the drag force is magnified 5 times to become more visual!).\n\n\n\n\n
\n\n\n\n\n\n% else:\n\n\n\n\n```python\nfrom IPython.display import HTML\n_s = \"\"\"\n\n\n
\nThe drag force is magnified 5 times! % endif
\n\n\n\n\n\"\"\"\nHTML(_s)\n```\n\n\n\n\nDynamic physical sketches, coupled to the numerical solution of\ndifferential equations, requires a program to produce a sketch for\nthe situation at each time level.\n[Pysketcher](https://github.com/hplgit/pysketcher) is such a tool.\nIn fact (and not surprising!) Figures [vib:app:pendulum:fig_problem](#vib:app:pendulum:fig_problem) and\n[vib:app:pendulum:fig_forces](#vib:app:pendulum:fig_forces) were drawn using Pysketcher.\nThe details of the drawings are explained in the\n[Pysketcher tutorial](http://hplgit.github.io/pysketcher/doc/web/index.html).\nHere, we outline how this type of sketch can be used to create an animated\nfree body diagram during the motion of a pendulum.\n\nPysketcher is actually a layer of useful abstractions on top of\nstandard plotting packages. This means that we in fact apply Matplotlib\nto make the animated free body diagram, but instead of dealing with a wealth\nof detailed Matplotlib commands, we can express the drawing in terms of\nmore high-level objects, e.g., objects for the wire, angle $\\theta$,\nbody with mass $m$, arrows for forces, etc. When the position of these\nobjects are given through variables, we can just couple those variables\nto the dynamic solution of our ODE and thereby make a unique drawing\nfor each $\\theta$ value in a simulation.\n\n### Writing the solver\n\nLet us start with the most familiar part of the current problem:\nwriting the solver function. We use Odespy for this purpose.\nWe also work with dimensionless equations. Since $\\theta$ can be\nviewed as dimensionless, we only need to introduce a dimensionless time,\nhere taken as $\\bar t = t/\\sqrt{L/g}$.\nThe resulting dimensionless mathematical model for $\\theta$,\nthe dimensionless angular velocity $\\omega$, the\ndimensionless wire force $\\bar S$, and the dimensionless\ndrag force $\\bar D$ is then\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d\\omega}{d\\bar t} = - \\alpha|\\omega|\\omega - \\sin\\theta,\n\\label{vib:app:pendulum_bodydia:eqth} \\tag{10}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d\\theta}{d\\bar t} = \\omega,\n\\label{vib:app:pendulum_bodydia:eqomega} \\tag{11}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar S = \\omega^2 + \\cos\\theta,\n\\label{vib:app:pendulum_bodydia:eqS} \\tag{12}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar D = -\\alpha |\\omega|\\omega,\n\\label{vib:app:pendulum_bodydia:eqD} \\tag{13}\n\\end{equation}\n$$\n\nwith\n\n$$\n\\alpha = \\frac{C_D\\varrho\\pi R^2L}{2m}\\thinspace .\n$$\n\nas a dimensionless parameter expressing the ratio of the drag force and\nthe gravity force. The dimensionless $\\omega$ is made non-dimensional\nby the time, so $\\omega\\sqrt{L/g}$ is the corresponding angular\nfrequency with dimensions.\n\n\n\nA suitable function for computing\n([10](#vib:app:pendulum_bodydia:eqth))-([13](#vib:app:pendulum_bodydia:eqD))\nis listed below.\n\n\n```python\ndef simulate(alpha, Theta, dt, T):\n import odespy\n\n def f(u, t, alpha):\n omega, theta = u\n return [-alpha*omega*abs(omega) - sin(theta),\n omega]\n\n import numpy as np\n Nt = int(round(T/float(dt)))\n t = np.linspace(0, Nt*dt, Nt+1)\n solver = odespy.RK4(f, f_args=[alpha])\n solver.set_initial_condition([0, Theta])\n u, t = solver.solve(\n t, terminate=lambda u, t, n: abs(u[n,1]) < 1E-3)\n omega = u[:,0]\n theta = u[:,1]\n S = omega**2 + np.cos(theta)\n drag = -alpha*np.abs(omega)*omega\n return t, theta, omega, S, drag\n```\n\n### Drawing the free body diagram\n\nThe `sketch` function below applies Pysketcher objects to build\na diagram like that in [Figure](#vib:app:pendulum:fig_forces),\nexcept that we have removed the rotation point $(x_0,y_0)$ and\nthe unit vectors in polar coordinates as these objects are not\nimportant for an animated free body diagram.\n\n\n```python\nimport sys\ntry:\n from pysketcher import *\nexcept ImportError:\n print 'Pysketcher must be installed from'\n print 'https://github.com/hplgit/pysketcher'\n sys.exit(1)\n\n# Overall dimensions of sketch\nH = 15.\nW = 17.\n\ndrawing_tool.set_coordinate_system(\n xmin=0, xmax=W, ymin=0, ymax=H,\n axis=False)\n\ndef sketch(theta, S, mg, drag, t, time_level):\n \"\"\"\n Draw pendulum sketch with body forces at a time level\n corresponding to time t. The drag force is in\n drag[time_level], the force in the wire is S[time_level],\n the angle is theta[time_level].\n \"\"\"\n import math\n a = math.degrees(theta[time_level]) # angle in degrees\n L = 0.4*H # Length of pendulum\n P = (W/2, 0.8*H) # Fixed rotation point\n\n mass_pt = path.geometric_features()['end']\n rod = Line(P, mass_pt)\n\n mass = Circle(center=mass_pt, radius=L/20.)\n mass.set_filled_curves(color='blue')\n rod_vec = rod.geometric_features()['end'] - \\\n rod.geometric_features()['start']\n unit_rod_vec = unit_vec(rod_vec)\n mass_symbol = Text('$m$', mass_pt + L/10*unit_rod_vec)\n\n rod_start = rod.geometric_features()['start'] # Point P\n vertical = Line(rod_start, rod_start + point(0,-L/3))\n\n def set_dashed_thin_blackline(*objects):\n \"\"\"Set linestyle of objects to dashed, black, width=1.\"\"\"\n for obj in objects:\n obj.set_linestyle('dashed')\n obj.set_linecolor('black')\n obj.set_linewidth(1)\n\n set_dashed_thin_blackline(vertical)\n set_dashed_thin_blackline(rod)\n angle = Arc_wText(r'$\\theta$', rod_start, L/6, -90, a,\n text_spacing=1/30.)\n\n magnitude = 1.2*L/2 # length of a unit force in figure\n force = mg[time_level] # constant (scaled eq: about 1)\n force *= magnitude\n mg_force = Force(mass_pt, mass_pt + force*point(0,-1),\n '', text_pos='end')\n force = S[time_level]\n force *= magnitude\n rod_force = Force(mass_pt, mass_pt - force*unit_vec(rod_vec),\n '', text_pos='end',\n text_spacing=(0.03, 0.01))\n force = drag[time_level]\n force *= magnitude\n air_force = Force(mass_pt, mass_pt -\n force*unit_vec((rod_vec[1], -rod_vec[0])),\n '', text_pos='end',\n text_spacing=(0.04,0.005))\n\n body_diagram = Composition(\n {'mg': mg_force, 'S': rod_force, 'air': air_force,\n 'rod': rod, 'body': mass\n 'vertical': vertical, 'theta': angle,})\n\n body_diagram.draw(verbose=0)\n drawing_tool.savefig('tmp_%04d.png' % time_level, crop=False)\n # (No cropping: otherwise movies will be very strange!)\n```\n\n### Making the animated free body diagram\n\nmathcal{I}_t now remains to couple the `simulate` and `sketch` functions.\nWe first run `simulate`:\n\n\n```python\nfrom math import pi, radians, degrees\nimport numpy as np\nalpha = 0.4\nperiod = 2*pi # Use small theta approximation\nT = 12*period # Simulate for 12 periods\ndt = period/40 # 40 time steps per period\na = 70 # Initial amplitude in degrees\nTheta = radians(a)\n\nt, theta, omega, S, drag = simulate(alpha, Theta, dt, T)\n```\n\nThe next step is to run through the time levels in the simulation and\nmake a sketch at each level:\n\n\n```python\nfor time_level, t_ in enumerate(t):\n sketch(theta, S, mg, drag, t_, time_level)\n```\n\nThe individual sketches are (by the `sketch` function) saved in files\nwith names `tmp_%04d.png`. These can be combined to videos using\n(e.g.) `ffmpeg`. A complete function `animate` for running the\nsimulation and creating video files is\nlisted below.\n\n\n```python\ndef animate():\n # Clean up old plot files\n import os, glob\n for filename in glob.glob('tmp_*.png') + glob.glob('movie.*'):\n os.remove(filename)\n # Solve problem\n from math import pi, radians, degrees\n import numpy as np\n alpha = 0.4\n period = 2*pi # Use small theta approximation\n T = 12*period # Simulate for 12 periods\n dt = period/40 # 40 time steps per period\n a = 70 # Initial amplitude in degrees\n Theta = radians(a)\n\n t, theta, omega, S, drag = simulate(alpha, Theta, dt, T)\n\n # Visualize drag force 5 times as large\n drag *= 5\n mg = np.ones(S.size) # Gravity force (needed in sketch)\n\n # Draw animation\n import time\n for time_level, t_ in enumerate(t):\n sketch(theta, S, mg, drag, t_, time_level)\n time.sleep(0.2) # Pause between each frame on the screen\n\n # Make videos\n prog = 'ffmpeg'\n filename = 'tmp_%04d.png'\n fps = 6\n codecs = {'flv': 'flv', 'mp4': 'libx264',\n 'webm': 'libvpx', 'ogg': 'libtheora'}\n for ext in codecs:\n lib = codecs[ext]\n cmd = '%(prog)s -i %(filename)s -r %(fps)s ' % vars()\n cmd += '-vcodec %(lib)s movie.%(ext)s' % vars()\n print(cmd)\n os.system(cmd)\n```\n\n## Motion of an elastic pendulum\n
\n\n\nConsider a pendulum as in [Figure](#vib:app:pendulum:fig_problem), but\nthis time the wire is elastic. The length of the wire when it is not\nstretched is $L_0$, while $L(t)$ is the stretched\nlength at time $t$ during the motion.\n\nStretching the elastic wire a distance $\\Delta L$ gives rise to a\nspring force $k\\Delta L$ in the opposite direction of the\nstretching. Let $\\boldsymbol{n}$ be a unit normal vector along the wire\nfrom the point $\\rpos_0=(x_0,y_0)$ and in the direction of $\\ith$, see\n[Figure](#vib:app:pendulum:fig_forces) for definition of $(x_0,y_0)$\nand $\\ith$. Obviously, we have $\\boldsymbol{n}=\\ith$, but in this modeling\nof an elastic pendulum we do not need polar coordinates. Instead, it\nis more straightforward to develop the equation in Cartesian\ncoordinates.\n\nA mathematical expression for $\\boldsymbol{n}$ is\n\n$$\n\\boldsymbol{n} = \\frac{\\rpos-\\rpos_0}{L(t)},\n$$\n\nwhere $L(t)=||\\rpos-\\rpos_0||$ is the current length of the elastic wire.\nThe position vector $\\rpos$ in Cartesian coordinates reads\n$\\rpos(t) = x(t)\\ii + y(t)\\jj$, where $\\ii$ and $\\jj$ are unit vectors\nin the $x$ and $y$ directions, respectively.\nmathcal{I}_t is convenient to introduce the Cartesian components $n_x$ and $n_y$\nof the normal vector:\n\n$$\n\\boldsymbol{n} = \\frac{\\rpos-\\rpos_0}{L(t)} = \\frac{x(t)-x_0}{L(t)}\\ii + \\frac{y(t)-y_0}{L(t)}\\jj = n_x\\ii + n_y\\jj\\thinspace .\n$$\n\nThe stretch $\\Delta L$ in the wire is\n\n$$\n\\Delta t = L(t) - L_0\\thinspace .\n$$\n\nThe force in the wire is then $-S\\boldsymbol{n}=-k\\Delta L\\boldsymbol{n}$.\n\nThe other forces are the gravity and the air resistance, just as in\n[Figure](#vib:app:pendulum:fig_forces). For motion in air we can\nneglect the added mass and buoyancy effects. The main difference is\nthat we have a *model* for $S$ in terms of the motion (as soon as we\nhave expressed $\\Delta L$ by $\\rpos$). For simplicity, we drop the air\nresistance term (but [Exercise 6: Simulate an elastic pendulum with air resistance](#vib:exer:pendulum_elastic_drag) asks\nyou to include it).\n\nNewton's second law of motion applied to the body now results in\n\n\n
\n\n$$\n\\begin{equation}\nm\\ddot\\rpos = -k(L-L_0)\\boldsymbol{n} - mg\\jj\n\\label{vib:app:pendulum_elastic:eq1} \\tag{14}\n\\end{equation}\n$$\n\nThe two components of\n([14](#vib:app:pendulum_elastic:eq1)) are\n\n\n
\n\n$$\n\\begin{equation}\n\\ddot x = -\\frac{k}{m}(L-L_0)n_x,\n\\label{_auto1} \\tag{15}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\label{vib:app:pendulum_elastic:eq2a} \\tag{16} \n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\ddot y = - \\frac{k}{m}(L-L_0)n_y - g\n\\label{vib:app:pendulum_elastic:eq2b} \\tag{17}\\thinspace .\n\\end{equation}\n$$\n\n### Remarks about an elastic vs a non-elastic pendulum\n\nNote that the derivation of the ODEs for an elastic pendulum is more\nstraightforward than for a classical, non-elastic pendulum,\nsince we avoid the details\nwith polar coordinates, but instead work with Newton's second law\ndirectly in Cartesian coordinates. The reason why we can do this is that\nthe elastic pendulum undergoes a general two-dimensional motion where\nall the forces are known or expressed as functions of $x(t)$ and $y(t)$,\nsuch that we get two ordinary differential equations.\nThe motion of the non-elastic pendulum, on the other hand, is constrained:\nthe body has to move along a circular path, and the force $S$ in the\nwire is unknown.\n\nThe non-elastic pendulum therefore leads to\na *differential-algebraic* equation, i.e., ODEs for $x(t)$ and $y(t)$\ncombined with an extra constraint $(x-x_0)^2 + (y-y_0)^2 = L^2$\nensuring that the motion takes place along a circular path.\nThe extra constraint (equation) is compensated by an extra unknown force\n$-S\\boldsymbol{n}$. Differential-algebraic equations are normally hard\nto solve, especially with pen and paper.\nFortunately, for the non-elastic pendulum we can do a\ntrick: in polar coordinates the unknown force $S$ appears only in the\nradial component of Newton's second law, while the unknown\ndegree of freedom for describing the motion, the angle $\\theta(t)$,\nis completely governed by the asimuthal component. This allows us to\ndecouple the unknowns $S$ and $\\theta$. But this is a kind of trick and\nnot a widely applicable method. With an elastic pendulum we use straightforward\nreasoning with Newton's 2nd law and arrive at a standard ODE problem that\n(after scaling) is easy to solve on a computer.\n\n### Initial conditions\n\nWhat is the initial position of the body? We imagine that first the\npendulum hangs in equilibrium in its vertical position, and then it is\ndisplaced an angle $\\Theta$. The equilibrium position is governed\nby the ODEs with the accelerations set to zero.\nThe $x$ component leads to $x(t)=x_0$, while the $y$ component gives\n\n$$\n0 = - \\frac{k}{m}(L-L_0)n_y - g = \\frac{k}{m}(L(0)-L_0) - g\\quad\\Rightarrow\\quad\nL(0) = L_0 + mg/k,\n$$\n\nsince $n_y=-11$ in this position. The corresponding $y$ value is then\nfrom $n_y=-1$:\n\n$$\ny(t) = y_0 - L(0) = y_0 - (L_0 + mg/k)\\thinspace .\n$$\n\nLet us now choose $(x_0,y_0)$ such that the body is at the origin\nin the equilibrium position:\n\n$$\nx_0 =0,\\quad y_0 = L_0 + mg/k\\thinspace .\n$$\n\nDisplacing the body an angle $\\Theta$ to the right leads to the\ninitial position\n\n$$\nx(0)=(L_0+mg/k)\\sin\\Theta,\\quad y(0)=(L_0+mg/k)(1-\\cos\\Theta)\\thinspace .\n$$\n\nThe initial velocities can be set to zero: $x'(0)=y'(0)=0$.\n\n### The complete ODE problem\n\nWe can summarize all the equations as follows:\n\n$$\n\\begin{align*}\n\\ddot x &= -\\frac{k}{m}(L-L_0)n_x,\n\\\\ \n\\ddot y &= -\\frac{k}{m}(L-L_0)n_y - g,\n\\\\ \nL &= \\sqrt{(x-x_0)^2 + (y-y_0)^2},\n\\\\ \nn_x &= \\frac{x-x_0}{L},\n\\\\ \nn_y &= \\frac{y-y_0}{L},\n\\\\ \nx(0) &= (L_0+mg/k)\\sin\\Theta,\n\\\\ \nx'(0) &= 0,\n\\\\ \ny(0) & =(L_0+mg/k)(1-\\cos\\Theta),\n\\\\ \ny'(0) &= 0\\thinspace .\n\\end{align*}\n$$\n\nWe insert $n_x$ and $n_y$ in the ODEs:\n\n\n
\n\n$$\n\\begin{equation}\n\\ddot x = -\\frac{k}{m}\\left(1 -\\frac{L_0}{L}\\right)(x-x_0),\n\\label{vib:app:pendulum_elastic:x} \\tag{18}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\ddot y = -\\frac{k}{m}\\left(1 -\\frac{L_0}{L}\\right)(y-y_0) - g,\n\\label{vib:app:pendulum_elastic:y} \\tag{19}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \nL = \\sqrt{(x-x_0)^2 + (y-y_0)^2},\n\\label{vib:app:pendulum_elastic:L} \\tag{20}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \nx(0) = (L_0+mg/k)\\sin\\Theta,\n\\label{vib:app:pendulum_elastic:x0} \\tag{21}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \nx'(0) = 0,\n\\label{vib:app:pendulum_elastic:vx0} \\tag{22}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \ny(0) =(L_0+mg/k)(1-\\cos\\Theta),\n\\label{vib:app:pendulum_elastic:y0} \\tag{23}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \ny'(0) = 0\\thinspace .\n\\label{vib:app:pendulum_elastic:vy0} \\tag{24}\n\\end{equation}\n$$\n\n### Scaling\n\nThe elastic pendulum model can be used to study both an elastic pendulum\nand a classic, non-elastic pendulum. The latter problem is obtained\nby letting $k\\rightarrow\\infty$. Unfortunately,\na serious problem with the ODEs\n([18](#vib:app:pendulum_elastic:x))-([19](#vib:app:pendulum_elastic:y)) is that for large $k$, we have a very large factor $k/m$ multiplied by a\nvery small number $1-L_0/L$, since for large $k$, $L\\approx L_0$ (very\nsmall deformations of the wire). The product is subject to\nsignificant round-off errors for many relevant physical values of\nthe parameters. To circumvent the problem, we introduce a scaling. This\nwill also remove physical parameters from the problem such that we end\nup with only one dimensionless parameter,\nclosely related to the elasticity of the wire. Simulations can then be\ndone by setting just this dimensionless parameter.\n\nThe characteristic length can be taken such that in equilibrium, the\nscaled length is unity, i.e., the characteristic length is $L_0+mg/k$:\n\n$$\n\\bar x = \\frac{x}{L_0+mg/k},\\quad \\bar y = \\frac{y}{L_0+mg/k}\\thinspace .\n$$\n\nWe must then also work with the scaled length $\\bar L = L/(L_0+mg/k)$.\n\nIntroducing $\\bar t=t/t_c$, where $t_c$ is a characteristic time we\nhave to decide upon later, one gets\n\n$$\n\\begin{align*}\n\\frac{d^2\\bar x}{d\\bar t^2} &=\n-t_c^2\\frac{k}{m}\\left(1 -\\frac{L_0}{L_0+mg/k}\\frac{1}{\\bar L}\\right)\\bar x,\\\\ \n\\frac{d^2\\bar y}{d\\bar t^2} &=\n-t_c^2\\frac{k}{m}\\left(1 -\\frac{L_0}{L_0+mg/k}\\frac{1}{\\bar L}\\right)(\\bar y-1)\n-t_c^2\\frac{g}{L_0 + mg/k},\\\\ \n\\bar L &= \\sqrt{\\bar x^2 + (\\bar y-1)^2},\\\\ \n\\bar x(0) &= \\sin\\Theta,\\\\ \n\\bar x'(0) &= 0,\\\\ \n\\bar y(0) & = 1 - \\cos\\Theta,\\\\ \n\\bar y'(0) &= 0\\thinspace .\n\\end{align*}\n$$\n\nFor a non-elastic pendulum with small angles, we know that the\nfrequency of the oscillations are $\\omega = \\sqrt{L/g}$. mathcal{I}_t is therefore\nnatural to choose a similar expression here, either the length in\nthe equilibrium position,\n\n$$\nt_c^2 = \\frac{L_0+mg/k}{g}\\thinspace .\n$$\n\nor simply the unstretched length,\n\n$$\nt_c^2 = \\frac{L_0}{g}\\thinspace .\n$$\n\nThese quantities are not very different (since the elastic model\nis valid only for quite small elongations), so we take the latter as it is\nthe simplest one.\n\nThe ODEs become\n\n$$\n\\begin{align*}\n\\frac{d^2\\bar x}{d\\bar t^2} &=\n-\\frac{L_0k}{mg}\\left(1 -\\frac{L_0}{L_0+mg/k}\\frac{1}{\\bar L}\\right)\\bar x,\\\\ \n\\frac{d^2\\bar y}{d\\bar t^2} &=\n-\\frac{L_0k}{mg}\\left(1 -\\frac{L_0}{L_0+mg/k}\\frac{1}{\\bar L}\\right)(\\bar y-1)\n-\\frac{L_0}{L_0 + mg/k},\\\\ \n\\bar L &= \\sqrt{\\bar x^2 + (\\bar y-1)^2}\\thinspace .\n\\end{align*}\n$$\n\nWe can now identify a dimensionless number\n\n$$\n\\beta = \\frac{L_0}{L_0 + mg/k} = \\frac{1}{1+\\frac{mg}{L_0k}},\n$$\n\nwhich is the ratio of the unstretched length and the\nstretched length in equilibrium. The non-elastic pendulum will have\n$\\beta =1$ ($k\\rightarrow\\infty$).\nWith $\\beta$ the ODEs read\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d^2\\bar x}{d\\bar t^2} =\n-\\frac{\\beta}{1-\\beta}\\left(1- \\frac{\\beta}{\\bar L}\\right)\\bar x,\n\\label{vib:app:pendulum_elastic:x:s} \\tag{25}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d^2\\bar y}{d\\bar t^2} =\n-\\frac{\\beta}{1-\\beta}\\left(1- \\frac{\\beta}{\\bar L}\\right)(\\bar y-1)\n-\\beta,\n\\label{vib:app:pendulum_elastic:y:s} \\tag{26}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar L = \\sqrt{\\bar x^2 + (\\bar y-1)^2},\n\\label{vib:app:pendulum_elastic:L:s} \\tag{27}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar x(0) = (1+\\epsilon)\\sin\\Theta,\n\\label{vib:app:pendulum_elastic:x0:s} \\tag{28}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d\\bar x}{d\\bar t}(0) = 0,\n\\label{vib:app:pendulum_elastic:vx0:s} \\tag{29}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar y(0) = 1 - (1+\\epsilon)\\cos\\Theta,\n\\label{vib:app:pendulum_elastic:y0:s} \\tag{30}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d\\bar y}{d\\bar t}(0) = 0,\n\\label{vib:app:pendulum_elastic:vy0:s} \\tag{31}\n\\end{equation}\n$$\n\nWe have here added a parameter $\\epsilon$, which is an additional\ndownward stretch of the wire at $t=0$. This parameter makes it possible\nto do a desired test: vertical oscillations of the pendulum. Without\n$\\epsilon$, starting the motion from $(0,0)$ with zero velocity will\nresult in $x=y=0$ for all times (also a good test!), but with\nan initial stretch so the body's position is $(0,\\epsilon)$, we\nwill have oscillatory vertical motion with amplitude $\\epsilon$ (see\n[Exercise 5: Simulate an elastic pendulum](#vib:exer:pendulum_elastic)).\n\n### Remark on the non-elastic limit\n\nWe immediately see that as $k\\rightarrow\\infty$ (i.e., we obtain a non-elastic\npendulum), $\\beta\\rightarrow 1$, $\\bar L\\rightarrow 1$, and we have\nvery small values $1-\\beta\\bar L^{-1}$ divided by very small values\n$1-\\beta$ in the ODEs. However, it turns out that we can set $\\beta$\nvery close to one and obtain a path of the body that within the visual\naccuracy of a plot does not show any elastic oscillations.\n(Should the division of very small values become a problem, one can\nstudy the limit by L'Hospital's rule:\n\n$$\n\\lim_{\\beta\\rightarrow 1}\\frac{1 - \\beta \\bar L^{-1}}{1-\\beta}\n= \\frac{1}{\\bar L},\n$$\n\nand use the limit $\\bar L^{-1}$ in the ODEs for $\\beta$ values very\nclose to 1.)\n\n## Vehicle on a bumpy road\n
\n\n\n\n
\n\nSketch of one-wheel vehicle on a bumpy road.
\n\n\n\n\n\nWe consider a very simplistic vehicle, on one wheel, rolling along a\nbumpy road. The oscillatory nature of the road will induce an external\nforcing on the spring system in the vehicle and cause vibrations.\n[Figure](#vib:app:bumpy:fig:sketch) outlines the situation.\n\nTo derive the equation that governs the motion, we must first establish\nthe position vector of the black mass at the top of the spring.\nSuppose the spring has length $L$ without any elongation or compression,\nsuppose the radius of the wheel is $R$, and suppose the height of the\nblack mass at the top is $H$. With the aid of the $\\rpos_0$ vector\nin [Figure](#vib:app:bumpy:fig:sketch), the position $\\rpos$ of\nthe center point of the mass is\n\n\n
\n\n$$\n\\begin{equation}\n\\rpos = \\rpos_0 + 2R\\jj + L\\jj + u\\jj + \\frac{1}{2} H\\jj,\\ \n\\label{_auto2} \\tag{32}\n\\end{equation}\n$$\n\nwhere $u$ is the elongation or compression in the spring according to\nthe (unknown and to be computed) vertical displacement $u$ relative to the\nroad. If the vehicle travels\nwith constant horizontal velocity $v$ and $h(x)$ is the shape of the\nroad, then the vector $\\rpos_0$ is\n\n$$\n\\rpos_0 = vt\\ii + h(vt)\\jj,\n$$\n\nif the motion starts from $x=0$ at time $t=0$.\n\nThe forces on the mass is the gravity, the spring force, and an optional\ndamping force that is proportional to the vertical velocity $\\dot u$. Newton's\nsecond law of motion then tells that\n\n$$\nm\\ddot\\rpos = -mg\\jj - s(u) - b\\dot u\\jj\\thinspace .\n$$\n\nThis leads to\n\n$$\nm\\ddot u = - s(u) - b\\dot u - mg -mh''(vt)v^2\n$$\n\nTo simplify a little bit, we omit the gravity force $mg$ in comparison with\nthe other terms. Introducing $u'$ for $\\dot u$ then gives a standard\ndamped, vibration equation with external forcing:\n\n\n
\n\n$$\n\\begin{equation}\nmu'' + bu' + s(u) = -mh''(vt)v^2\\thinspace .\n\\label{_auto3} \\tag{33}\n\\end{equation}\n$$\n\nSince the road is normally known just as a set of array values, $h''$ must\nbe computed by finite differences. Let $\\Delta x$ be the spacing between\nmeasured values $h_i= h(i\\Delta x)$ on the road. The discrete second-order\nderivative $h''$ reads\n\n$$\nq_i = \\frac{h_{i-1} - 2h_i + h_{i+1}}{\\Delta x^2}, \\quad i=1,\\ldots,N_x-1\\thinspace .\n$$\n\nWe may for maximum simplicity set\nthe end points as $q_0=q_1$ and $q_{N_x}=q_{N_x-1}$.\nThe term $-mh''(vt)v^2$ corresponds to a force with discrete time values\n\n$$\nF^n = -mq_n v^2,\\quad \\Delta t = v^{-1}\\Delta x\\thinspace .\n$$\n\nThis force can be directly used in a numerical model\n\n$$\n[mD_tD_t u + bD_{2t} u + s(u) = F]^n\\thinspace .\n$$\n\nSoftware for computing $u$ and also making an animated sketch of\nthe motion like we did in the section [Dynamic free body diagram during pendulum motion](#vib:app:pendulum_bodydia)\nis found in a separate project on the web:\n. You may start looking at the\n\"tutorial\":\n% if FORMAT == 'pdflatex':\n\"http://hplgit.github.io/bumpy/doc/pub/bumpy.pdf\".\n% else:\n\"http://hplgit.github.io/bumpy/doc/pub/bumpy.html\".\n% endif\n\n## Bouncing ball\n
\n\nA bouncing ball is a ball in free vertically fall until it impacts the\nground, but during the impact, some kinetic energy is lost, and a new\nmotion upwards with reduced velocity starts. After the motion is retarded,\na new free fall starts, and the process is repeated. At some point the\nvelocity close to the ground is so small that the ball is considered\nto be finally at rest.\n\nThe motion of the ball falling in air is governed by Newton's second\nlaw $F=ma$, where $a$ is the acceleration of the body, $m$ is the mass,\nand $F$ is the sum of all forces. Here, we neglect the air resistance\nso that gravity $-mg$ is the only force. The height of the ball is\ndenoted by $h$ and $v$ is the velocity. The relations between $h$, $v$, and\n$a$,\n\n$$\nh'(t)= v(t),\\quad v'(t) = a(t),\n$$\n\ncombined with Newton's second law gives the ODE model\n\n\n
\n\n$$\n\\begin{equation}\nh^{\\prime\\prime}(t) = -g,\n\\label{vib:app:bouncing:ball:h2eq} \\tag{34}\n\\end{equation}\n$$\n\nor expressed alternatively as a system of first-order equations:\n\n\n
\n\n$$\n\\begin{equation}\nv'(t) = -g,\n\\label{vib:app:bouncing:ball:veq} \\tag{35} \n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \nh'(t) = v(t)\\thinspace .\n\\label{vib:app:bouncing:ball:heq} \\tag{36}\n\\end{equation}\n$$\n\nThese equations govern the motion as long as the ball is away from\nthe ground by a small distance $\\epsilon_h > 0$. When $h<\\epsilon_h$,\nwe have two cases.\n\n1. The ball impacts the ground, recognized by a sufficiently large negative\n velocity ($v<-\\epsilon_v$). The velocity then changes sign and is\n reduced by a factor $C_R$, known as the [coefficient of restitution](http://en.wikipedia.org/wiki/Coefficient_of_restitution).\n For plotting purposes, one may set $h=0$.\n\n2. The motion stops, recognized by a sufficiently small velocity\n ($|v|<\\epsilon_v$) close to the ground.\n\n## Two-body gravitational problem\n
\n\nConsider two astronomical objects $A$ and $B$ that attract each other\nby gravitational forces. $A$ and $B$ could be two stars in a binary\nsystem, a planet orbiting a star, or a moon orbiting a planet.\nEach object is acted upon by the\ngravitational force due to the other object. Consider motion in a plane\n(for simplicity) and let $(x_A,y_A)$ and $(x_B,y_B)$ be the\npositions of object $A$ and $B$, respectively.\n\n### The governing equations\n\nNewton's second law of motion applied to each object is all we need\nto set up a mathematical model for this physical problem:\n\n\n
\n\n$$\n\\begin{equation}\nm_A\\ddot\\x_A = \\F,\n\\label{_auto4} \\tag{37}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \nm_B\\ddot\\x_B = -\\F,\n\\label{_auto5} \\tag{38}\n\\end{equation}\n$$\n\nwhere $F$ is the gravitational force\n\n$$\n\\F = \\frac{Gm_Am_B}{||\\rpos||^3}\\rpos,\n$$\n\nwhere\n\n$$\n\\rpos(t) = \\x_B(t) - \\x_A(t),\n$$\n\nand $G$ is the gravitational constant:\n$G=6.674\\cdot 10^{-11}\\hbox{ Nm}^2/\\hbox{kg}^2$.\n\n### Scaling\n\nA problem with these equations is that the parameters are very large\n($m_A$, $m_B$, $||\\rpos||$) or very small ($G$). The rotation time\nfor binary stars can be very small and large as well. mathcal{I}_t is therefore\nadvantageous to scale the equations.\nA natural length scale could be the initial distance between the objects:\n$L=\\rpos(0)$. We write the dimensionless quantities as\n\n$$\n\\bar\\x_A = \\frac{\\x_A}{L},\\quad\\bar\\x_B = \\frac{\\x_B}{L},\\quad\n\\bar t = \\frac{t}{t_c}\\thinspace .\n$$\n\nThe gravity force is transformed to\n\n$$\n\\F = \\frac{Gm_Am_B}{L^2||\\bar\\rpos||^3}\\bar\\rpos,\\quad \\bar\\rpos = \\bar\\x_B - \\bar\\x_A,\n$$\n\nso the first ODE for $\\x_A$ becomes\n\n$$\n\\frac{d^2 \\bar\\x_A}{d\\bar t^2} =\n\\frac{Gm_Bt_c^2}{L^3}\\frac{\\bar\\rpos}{||\\bar\\rpos||^3}\\thinspace .\n$$\n\nAssuming that quantities with a bar and their derivatives are around unity\nin size, it is natural to choose $t_c$ such that the fraction $Gm_Bt_c/L^2=1$:\n\n$$\nt_c = \\sqrt{\\frac{L^3}{Gm_B}}\\thinspace .\n$$\n\nFrom the other equation for $\\x_B$ we get another candidate for $t_c$ with\n$m_A$ instead of $m_B$. Which mass we choose play a role if $m_A\\ll m_B$ or\n$m_B\\ll m_A$. One solution is to use the sum of the masses:\n\n$$\nt_c = \\sqrt{\\frac{L^3}{G(m_A+m_B)}}\\thinspace .\n$$\n\nTaking a look at [Kepler's laws](https://en.wikipedia.org/wiki/Kepler%27s_laws_of_planetary_motion) of planetary motion, the orbital period for a planet around the star is given by the $t_c$ above, except for a missing factor of $2\\pi$,\nbut that means that $t_c^{-1}$ is just the angular frequency of the motion.\nOur characteristic time $t_c$ is therefore highly relevant.\nIntroducing the dimensionless number\n\n$$\n\\alpha = \\frac{m_A}{m_B},\n$$\n\nwe can write the dimensionless ODE as\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d^2 \\bar\\x_A}{d\\bar t^2} =\n\\frac{1}{1+\\alpha}\\frac{\\bar\\rpos}{||\\bar\\rpos||^3},\n\\label{_auto6} \\tag{39}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d^2 \\bar\\x_B}{d\\bar t^2} =\n\\frac{1}{1+\\alpha^{-1}}\\frac{\\bar\\rpos}{||\\bar\\rpos||^3}\\thinspace .\n\\label{_auto7} \\tag{40}\n\\end{equation}\n$$\n\nIn the limit $m_A\\ll m_B$, i.e., $\\alpha\\ll 1$,\nobject B stands still, say $\\bar\\x_B=0$, and object\nA orbits according to\n\n$$\n\\frac{d^2 \\bar\\x_A}{d\\bar t^2} = -\\frac{\\bar\\x_A}{||\\bar \\x_A||^3}\\thinspace .\n$$\n\n### Solution in a special case: planet orbiting a star\n\nTo better see the motion, and that our scaling is reasonable,\nwe introduce polar coordinates $r$ and $\\theta$:\n\n$$\n\\bar\\x_A = r\\cos\\theta\\ii + r\\sin\\theta\\jj,\n$$\n\nwhich means $\\bar\\x_A$ can be written as $\\bar\\x_A =r\\ir$. Since\n\n$$\n\\frac{d}{dt}\\ir = \\dot\\theta\\ith,\\quad \\frac{d}{dt}\\ith = -\\dot\\theta\\ir,\n$$\n\nwe have\n\n$$\n\\frac{d^2 \\bar\\x_A}{d\\bar t^2} =\n(\\ddot r - r\\dot\\theta^2)\\ir + (r\\ddot\\theta + 2\\dot r\\dot\\theta)\\ith\\thinspace .\n$$\n\nThe equation of motion for mass A is then\n\n$$\n\\begin{align*}\n\\ddot r - r\\dot\\theta^2 &= -\\frac{1}{r^2},\\\\ \nr\\ddot\\theta + 2\\dot r\\dot\\theta &= 0\\thinspace .\n\\end{align*}\n$$\n\nThe special case of circular motion, $r=1$, fulfills the equations, since\nthe latter equation then gives $\\dot\\theta =\\hbox{const}$ and\nthe former then gives $\\dot\\theta = 1$, i.e., the motion is\n$r(t)=1$, $\\theta(t)=t$, with unit angular frequency as expected and\nperiod $2\\pi$ as expected.\n\n\n## Electric circuits\n\nAlthough the term \"mechanical vibrations\" is used in the present\nbook, we must mention that the same type of equations arise\nwhen modeling electric circuits.\nThe current $I(t)$ in a\ncircuit with an inductor with inductance $L$, a capacitor with\ncapacitance $C$, and overall resistance $R$, is governed by\n\n\n
\n\n$$\n\\begin{equation}\n\\ddot I + \\frac{R}{L}\\dot I + \\frac{1}{LC}I = \\dot V(t),\n\\label{_auto8} \\tag{41}\n\\end{equation}\n$$\n\nwhere $V(t)$ is the voltage source powering the circuit.\nThis equation has the same form as the general model considered in\nthe section [vib:model2](#vib:model2) if we set $u=I$, $f(u^{\\prime})=bu^{\\prime}$\nand define $b=R/L$, $s(u) = L^{-1}C^{-1}u$, and $F(t)=\\dot V(t)$.\n\n\n# Exercises\n\n\n\n\n\n## Exercise 1: Simulate resonance\n
\n\n\nWe consider the scaled ODE model\n([4](#vib:app:mass_gen:scaled)) from the section [General mechanical vibrating system](#vib:app:mass_gen).\nAfter scaling, the amplitude of $u$ will have a size about unity\nas time grows and the effect of the initial conditions die out due\nto damping. However, as $\\gamma\\rightarrow 1$, the amplitude of $u$\nincreases, especially if $\\beta$ is small. This effect is called\n*resonance*. The purpose of this exercise is to explore resonance.\n\n\n**a)**\nFigure out how the `solver` function in `vib.py` can be called\nfor the scaled ODE ([4](#vib:app:mass_gen:scaled)).\n\n\n\n**Solution.**\nComparing the scaled ODE ([4](#vib:app:mass_gen:scaled))\nwith the ODE ([3](#vib:app:mass_gen:equ)) with dimensions, we\nrealize that the parameters in the latter must be set as\n\n * $m=1$\n\n * $f(\\dot u) = 2\\beta |\\dot u|\\dot u$\n\n * $s(u)=ku$\n\n * $F(t)=\\sin(\\gamma t)$\n\n * $I=Ik/A$\n\n * $V=\\sqrt{mk}V/A$\n\nThe expected period is $2\\pi$, so simulating for $N$ periods means\n$T=2\\pi N$. Having $m$ time steps per period means $\\Delta t = 2\\pi/m$.\n\nSuppose we just choose $I=1$ and $V=0$. Simulating for 20 periods with\n60 time steps per period, implies the following\n`solver` call to run the scaled model:\n\n\n```python\nu, t = solver(I=1, V=0, m=1, b=2*beta, s=lambda u: u,\n F=lambda t: sin(gamma*t), dt=2*pi/60,\n T=2*pi*20, damping='quadratic')\n```\n\n\n\n**b)**\nRun $\\gamma =5, 1.5, 1.1, 1$ for $\\beta=0.005, 0.05, 0.2$.\nFor each $\\beta$ value, present an image with plots of $u(t)$ for\nthe four $\\gamma$ values.\n\n\n\n**Solution.**\nAn appropriate program is\n\n\n```python\nfrom vib import solver, visualize, plt\nfrom math import pi, sin\nimport numpy as np\n\nbeta_values = [0.005, 0.05, 0.2]\nbeta_values = [0.00005]\ngamma_values = [5, 1.5, 1.1, 1]\nfor i, beta in enumerate(beta_values):\n for gamma in gamma_values:\n u, t = solver(I=1, V=0, m=1, b=2*beta, s=lambda u: u,\n F=lambda t: sin(gamma*t), dt=2*pi/60,\n T=2*pi*20, damping='quadratic')\n visualize(u, t, title='gamma=%g' %\n gamma, filename='tmp_%s' % gamma)\n print gamma, 'max u amplitude:', np.abs(u).max()\n for ext in 'png', 'pdf':\n cmd = 'doconce combine_images '\n cmd += ' '.join(['tmp_%s.' % gamma + ext\n for gamma in gamma_values])\n cmd += ' resonance%d.' % (i+1) + ext\n os.system(cmd)\nraw_input()\n```\n\nFor $\\beta = 0.2$ we see that the amplitude is not far from unity:\n\n\n\n\n
\n\n\n\n\n\nFor $\\beta =0.05$ we see that as $\\gamma\\rightarrow 1$, the amplitude grows:\n\n\n\n\n
\n\n\n\n\n\nFinally, a small damping ($\\beta = 0.005$) amplifies the amplitude significantly (by a factor of 10) for $\\gamma=1$:\n\n\n\n\n
\n\n\n\n\n\nFor a very small $\\beta=0.00005$, the amplitude grows linearly up to\nabout 60 for $\\bar t\\in [0,120]$.\n\n\n\nFilename: `resonance`.\n\n\n\n\n\n\n\n\n## Exercise 2: Simulate oscillations of a sliding box\n
\n\nConsider a sliding box on a flat surface as modeled in the section [A sliding mass attached to a spring](#vib:app:mass_sliding). As spring force we choose the nonlinear\nformula\n\n$$\ns(u) = \\frac{k}{\\alpha}\\tanh(\\alpha u) = ku + \\frac{1}{3}\\alpha^2 ku^3 + \\frac{2}{15}\\alpha^4 k u^5 + \\Oof{u^6}\\thinspace .\n$$\n\n**a)**\nPlot $g(u)=\\alpha^{-1}\\tanh(\\alpha u)$ for various values of $\\alpha$.\nAssume $u\\in [-1,1]$.\n\n\n\n**Solution.**\nHere is a function that does the plotting:\n\n\n```python\n%matplotlib inline\n\nimport scitools.std as plt\nimport numpy as np\n\ndef plot_spring():\n alpha_values = [1, 2, 3, 10]\n s = lambda u: 1.0/alpha*np.tanh(alpha*u)\n u = np.linspace(-1, 1, 1001)\n for alpha in alpha_values:\n print alpha, s(u)\n plt.plot(u, s(u))\n plt.hold('on')\n plt.legend([r'$\\alpha=%g$' % alpha for alpha in alpha_values])\n plt.xlabel('u'); plt.ylabel('Spring response $s(u)$')\n plt.savefig('tmp_s.png'); plt.savefig('tmp_s.pdf')\n```\n\n\n\n\n
\n\n\n\n\n\n\n\n**b)**\nScale the equations using $I$ as scale for $u$ and $\\sqrt{m/k}$ as\ntime scale.\n\n\n\n**Solution.**\nInserting the dimensionless dependent and independent variables,\n\n$$\n\\bar u = \\frac{u}{I},\\quad \\bar t = \\frac{t}{\\sqrt{m/k}},\n$$\n\nin the problem\n\n$$\nm\\ddot u + \\mu mg\\hbox{sign}(\\dot u) + s(u) = 0,\\quad u(0)=I,\\ \\dot u(0)=V,\n$$\n\ngives\n\n$$\n\\frac{d^2\\bar u}{d\\bar t^2} + \\frac{\\mu mg}{kI}\\hbox{sign}\\left(\n\\frac{d\\bar u}{d\\bar t}\\right) + \\frac{1}{\\alpha I}\\tanh(\\alpha I\\bar u)\n= 0,\\quad \\bar u(0)=1,\\ \\frac{d\\bar u}{d\\bar t}(0)=\\frac{V\\sqrt{mk}}{kI}\\thinspace .\n$$\n\nWe can now identify three dimensionless parameters,\n\n$$\n\\beta = \\frac{\\mu mg}{kI},\\quad\n\\gamma = \\alpha I,\\quad \\delta = \\frac{V\\sqrt{mk}}{kI}\\thinspace .\n$$\n\nThe scaled problem can then be written\n\n$$\n\\frac{d^2\\bar u}{d\\bar t^2} + \\beta\\hbox{sign}\\left(\n\\frac{d\\bar u}{d\\bar t}\\right) + \\gamma^{-1}\\tanh(\\gamma \\bar u)\n= 0,\\quad \\bar u(0)=1,\\ \\frac{d\\bar u}{d\\bar t}(0)=\\delta\\thinspace .\n$$\n\nThe initial set of 7 parameters $(\\mu, m, g, k, \\alpha, I, V)$ are\nreduced to 3 dimensionless combinations.\n\n\n\n**c)**\nImplement the scaled model in b). Run it for some values of\nthe dimensionless parameters.\n\n\n\n**Solution.**\nWe use Odespy to solve the ODE, which requires rewriting the ODE as a\nsystem of two first-order ODEs:\n\n$$\n\\begin{align*}\nv' &= - \\beta\\hbox{sign}(v) - \\gamma^{-1}\\tanh(\\gamma \\bar u),\\\\ \nu' &= v,\n\\end{align*}\n$$\n\nwith initial conditions $v(0)=\\delta$ and $u(0)=1$. Here, $u(t)$ corresponds\nto the previous $\\bar u(\\bar t)$, while $v(t)$ corresponds to\n$d\\bar u/d\\bar t (\\bar t)$. The code can be like this:\n\n\n```python\ndef simulate(beta, gamma, delta=0,\n num_periods=8, time_steps_per_period=60):\n # Use oscillations without friction to set dt and T\n P = 2*np.pi\n dt = P/time_steps_per_period\n T = num_periods*P\n t = np.linspace(0, T, time_steps_per_period*num_periods+1)\n import odespy\n def f(u, t, beta, gamma):\n # Note the sequence of unknowns: v, u (v=du/dt)\n v, u = u\n return [-beta*np.sign(v) - 1.0/gamma*np.tanh(gamma*u), v]\n #return [-beta*np.sign(v) - u, v]\n\n solver = odespy.RK4(f, f_args=(beta, gamma))\n solver.set_initial_condition([delta, 1]) # sequence must match f\n uv, t = solver.solve(t)\n u = uv[:,1] # recall sequence in f: v, u\n v = uv[:,0]\n return u, t\n```\n\nWe simulate for an almost linear spring in the regime of $\\bar u$ (recall\nthat $\\bar u\\in [0,1]$ since $u$ is scaled with $I$), which corresponds\nto $\\alpha = 1$ in a) and therefore $\\gamma =1$. Then we can try a\nspring whose force quickly flattens out like $\\alpha=5$ in a), which\ncorresponds to $\\gamma = 5$ in the scaled model. A third option is\nto have a truly linear spring, e.g., $\\gamma =0.1$. After some\nexperimentation we realize that $\\beta=0,0.05, 0.1$ are relevant values.\n\n\n\n\n
\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n\n\nFilename: `sliding_box`.\n\n\n\n\n\n\n\n\n## Exercise 3: Simulate a bouncing ball\n
\n\nThe section [Bouncing ball](#vib:app:bouncing_ball) presents a model for a bouncing\nball.\nChoose one of the two ODE formulation, ([34](#vib:app:bouncing:ball:h2eq)) or\n([35](#vib:app:bouncing:ball:veq))-([36](#vib:app:bouncing:ball:heq)),\nand simulate the motion of a bouncing ball. Plot $h(t)$. Think about how to\nplot $v(t)$.\n\n\n\n**Hint.**\nA naive implementation may get stuck in repeated impacts for large time\nstep sizes. To avoid this situation, one can introduce a state\nvariable that holds the mode of the motion: free fall, impact, or rest.\nTwo consecutive impacts imply that the motion has stopped.\n\n\n\n\n\n**Solution.**\nA tailored `solver` function and some plotting statements go like\n\n\n```python\nimport numpy as np\n\ndef solver(H, C_R, dt, T, eps_v=0.01, eps_h=0.01):\n \"\"\"\n Simulate bouncing ball until it comes to rest. Time step dt.\n h(0)=H (initial height). T: maximum simulation time.\n Method: Euler-Cromer.\n \"\"\"\n dt = float(dt)\n Nt = int(round(T/dt))\n h = np.zeros(Nt+1)\n v = np.zeros(Nt+1)\n t = np.linspace(0, Nt*dt, Nt+1)\n g = 0.81\n\n v[0] = 0\n h[0] = H\n mode = 'free fall'\n for n in range(Nt):\n v[n+1] = v[n] - dt*g\n h[n+1] = h[n] + dt*v[n+1]\n\n if h[n+1] < eps_h:\n #if abs(v[n+1]) > eps_v: # handles large dt, but is wrong\n if v[n+1] < -eps_v:\n # Impact\n v[n+1] = -C_R*v[n+1]\n h[n+1] = 0\n if mode == 'impact':\n # impact twice\n return h[:n+2], v[:n+2], t[:n+2]\n mode = 'impact'\n elif abs(v[n+1]) < eps_v:\n mode = 'rest'\n v[n+1] = 0\n h[n+1] = 0\n return h[:n+2], v[:n+2], t[:n+2]\n else:\n mode = 'free fall'\n else:\n mode = 'free fall'\n print '%4d v=%8.5f h=%8.5f %s' % (n, v[n+1], h[n+1], mode)\n raise ValueError('T=%g is too short simulation time' % T)\n\nimport matplotlib.pyplot as plt\nh, v, t = solver(\n H=1, C_R=0.8, T=100, dt=0.0001, eps_v=0.01, eps_h=0.01)\nplt.plot(t, h)\nplt.legend('h')\nplt.savefig('tmp_h.png'); plt.savefig('tmp_h.pdf')\nplt.figure()\nplt.plot(t, v)\nplt.legend('v')\nplt.savefig('tmp_v.png'); plt.savefig('tmp_v.pdf')\nplt.show()\n```\n\n\n\n\n
\n\n\n\n\n\n\nFilename: `bouncing_ball`.\n\n\n\n\n\n\n\n\n## Exercise 4: Simulate a simple pendulum\n
\n\nSimulation of simple pendulum can be carried out by using\nthe mathematical model derived in the section [Motion of a pendulum](#vib:app:pendulum)\nand calling up functionality in the [`vib.py`](${src_vib}/vib.py)\nfile (i.e., solve the second-order ODE by centered finite differences).\n\n\n**a)**\nScale the model. Set up the dimensionless governing equation for $\\theta$\nand expressions for dimensionless drag and wire forces.\n\n\n\n**Solution.**\nThe angle is measured in radians so we may think of this quantity as\ndimensionless, or we may scale it by the initial condition to obtain\na primary unknown that lies in $[-1,1]$. We go for the former strategy here.\n\nDimensionless time $\\bar t$ is introduced as $t/t_c$ for some suitable\ntime scale $t_c$.\n\nInserted in the two governing equations\n([8](#vib:app:pendulum:thetaeq)) and ([6](#vib:app:pendulum:ir)),\nfor the\ntwo unknowns $\\theta$ and $S$, respectively, we achieve\n\n$$\n\\begin{align*}\n-S + mg\\cos\\theta &= -\\frac{1}{t_c}L\\frac{d\\theta}{d\\bar t},\\\\ \n\\frac{1}{t_c^2}m\\frac{d^2\\theta}{d\\bar t^2} +\n\\frac{1}{2}C_D\\varrho AL \\frac{1}{t_c^2}\\left\\vert\n\\frac{d\\theta}{d\\bar t}\\right\\vert\n\\frac{d\\theta}{d\\bar t}\n+ \\frac{mg}{L}\\sin\\theta &= 0\\thinspace .\n\\end{align*}\n$$\n\nWe multiply the latter equation by $t_c^2/m$ to make each term\ndimensionless:\n\n$$\n\\frac{d^2\\theta}{d\\bar t^2} +\n\\frac{1}{2m}C_D\\varrho AL \\left\\vert\n\\frac{d\\theta}{d\\bar t}\\right\\vert\n\\frac{d\\theta}{d\\bar t}\n+ \\frac{t_c^2g}{L}\\sin\\theta = 0\\thinspace .\n$$\n\nAssuming that the acceleration term and the\ngravity term to be the dominating terms, these should balance, so\n$t_c^2g/L=1$, giving $t_c = \\sqrt{g/L}$. With $A=\\pi R^2$ we get the\ndimensionless ODEs\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d^2\\theta}{d\\bar t^2} +\n\\alpha\\left\\vert\\frac{d\\theta}{d\\bar t}\\right\\vert\\frac{d\\theta}{d\\bar t} +\n\\sin\\theta = 0,\n\\label{vib:exer:pendulum_simple:eq:ith:s} \\tag{42}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{S}{mg} = \\left(\\frac{d\\theta}{d\\bar t}\\right)^2 + \\cos\\theta,\n\\label{vib:exer:pendulum_simple:eq:ir:s} \\tag{43}\n\\end{equation}\n$$\n\nwhere $\\alpha$ is a dimensionless drag coefficient\n\n$$\n\\alpha = \\frac{C_D\\varrho\\pi R^2L}{2m}\\thinspace .\n$$\n\nNote that in ([43](#vib:exer:pendulum_simple:eq:ir:s)) we have divided by\n$mg$, which is in fact a force scale, making the gravity force unity\nand also $S/mg=1$ in the equilibrium position $\\theta=0$. We may\nintroduce\n\n$$\n\\bar S = S/mg\n$$\n\nas a dimensionless drag force.\n\nThe parameter $\\alpha$ is about\nthe ratio of the drag force and the gravity force:\n\n$$\n\\frac{|\\frac{1}{2} C_D\\varrho \\pi R^2 |v|v|}{|mg|}\\sim\n\\frac{C_D\\varrho \\pi R^2 L^2 t_c^{-2}}{mg}\n\\left|\\frac{d\\bar\\theta}{d\\bar t}\\right|\\frac{d\\bar\\theta}{d\\bar t}\n\\sim \\frac{C_D\\varrho \\pi R^2 L}{2m}\\Theta^2 = \\alpha \\Theta^2\\thinspace .\n$$\n\n(We have that $\\theta(t)/d\\Theta$ is in $[-1,1]$, so we expect\nsince $\\Theta^{-1}d\\bar\\theta/d\\bar t$ to be around unity. Here,\n$\\Theta=\\theta(0)$.)\n\nLet us introduce $\\omega$ for the dimensionless angular velocity,\n\n$$\n\\omega = \\frac{d\\theta}{d\\bar t}\\thinspace .\n$$\n\nWhen $\\theta$ is computed, the dimensionless wire and drag forces\nare computed by\n\n$$\n\\begin{align*}\n\\bar S &= \\omega^2 + \\cos\\theta,\\\\ \n\\bar D &= -\\alpha |\\omega|\\omega\\thinspace .\n\\end{align*}\n$$\n\n\n\n**b)**\nWrite a function for computing\n$\\theta$ and the dimensionless drag force and the force in the wire,\nusing the `solver` function in\nthe `vib.py` file. Plot these three quantities\nbelow each other (in subplots) so the graphs can be compared.\nRun two cases, first one in the limit of $\\Theta$ small and\nno drag, and then a second one with $\\Theta=40$ degrees and $\\alpha=0.8$.\n\n\n\n**Solution.**\nThe first step is to realize how to utilize the `solver` function for\nour dimensionless model. Introducing `Theta` for $\\Theta$, the\narguments to `solver` must be set as\n\n\n```python\nI = Theta\nV = 0\nm = 1\nb = alpha\ns = lambda u: sin(u)\nF = lambda t: 0\ndamping = 'quadratic'\n```\n\nAfter computing $\\theta$, we need to find $\\omega$ by finite differences:\n\n$$\n\\omega^n = \\frac{\\theta^{n+1}-\\theta^{n-1}}{2\\Delta t},\n\\ n=1,\\ldots,N_t-1,\\quad \\omega^0=\\frac{\\theta^1-\\theta^0}{\\Delta t},\n\\ \\omega^{N_t}=\\frac{\\theta^{N_t}-\\theta^{N_t-1}}{\\Delta t}\\thinspace .\n$$\n\nThe duration of the simulation and the time step can be computed on\nbasis of the analytical insight we have for small $\\theta$\n($\\theta\\approx \\Theta\\cos(t)$). A complete function then reads\n\n\n```python\ndef simulate(Theta, alpha, num_periods=10):\n # Dimensionless model requires the following parameters:\n from math import sin, pi\n\n I = Theta\n V = 0\n m = 1\n b = alpha\n s = lambda u: sin(u)\n F = lambda t: 0\n damping = 'quadratic'\n\n # Estimate T and dt from the small angle solution\n P = 2*pi # One period (theta small, no drag)\n dt = P/40 # 40 intervals per period\n T = num_periods*P\n\n theta, t = solver(I, V, m, b, s, F, dt, T, damping)\n omega = np.zeros(theta.size)\n omega[1:-1] = (theta[2:] - theta[:-2])/(2*dt)\n omega[0] = (theta[1] - theta[0])/dt\n omega[-1] = (theta[-1] - theta[-2])/dt\n\n S = omega**2 + np.cos(theta)\n D = alpha*np.abs(omega)*omega\n return t, theta, S, D\n```\n\nAssuming imports like\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n```\n\nthe following function visualizes $\\theta$, $\\bar S$, and $\\bar D$\nwith three subplots:\n\n\n```python\ndef visualize(t, theta, S, D, filename='tmp'):\n f, (ax1, ax2, ax3) = plt.subplots(3, sharex=True, sharey=False)\n ax1.plot(t, theta)\n ax1.set_title(r'$\\theta(t)$')\n ax2.plot(t, S)\n ax2.set_title(r'Dimensonless force in the wire')\n ax3.plot(t, D)\n ax3.set_title(r'Dimensionless drag force')\n plt.savefig('%s.png' % filename)\n plt.savefig('%s.pdf' % filename)\n```\n\nA suitable main program is\n\n\n```python\nimport math\n# Rough verification that small theta and no drag gives cos(t)\nTheta = 1.0\nalpha = 0\nt, theta, S, D = simulate(Theta, alpha, num_periods=4)\n# Scale theta by Theta (easier to compare with cos(t))\ntheta /= Theta\nvisualize(t, theta, S, D, filename='pendulum_verify')\n\nTheta = math.radians(40)\nalpha = 0.8\nt, theta, S, D = simulate(Theta, alpha)\nvisualize(t, theta, S, D, filename='pendulum_alpha0.8_Theta40')\nplt.show()\n```\n\nThe \"verification\" case looks good (at least when the `solver` function\nhas been thoroughly verified in other circumstances):\n\n\n\n\n
\n\n\n\n\n\nThe \"real case\" shows how quickly the drag force is reduced, even when\nwe set $\\alpha$ to a significant value (0.8):\n\n\n\n\n
\n\n\n\n\n\n\n\n\n\n\nFilename: `simple_pendulum`.\n\n\n\n\n\n\n\n\n## Exercise 5: Simulate an elastic pendulum\n
\n\nThe section [Motion of an elastic pendulum](#vib:app:pendulum_elastic) describes a model for an elastic\npendulum, resulting in a system of two ODEs. The purpose of this\nexercise is to implement the scaled model, test the software, and\ngeneralize the model.\n\n\n**a)**\nWrite a function `simulate`\nthat can simulate an elastic pendulum using the scaled model.\nThe function should have the following arguments:\n\n\n```python\ndef simulate(\n beta=0.9, # dimensionless parameter\n Theta=30, # initial angle in degrees\n epsilon=0, # initial stretch of wire\n num_periods=6, # simulate for num_periods\n time_steps_per_period=60, # time step resolution\n plot=True, # make plots or not\n ):\n```\n\nTo set the total simulation time and the time step, we\nuse our knowledge of the scaled, classical, non-elastic pendulum:\n$u^{\\prime\\prime} + u = 0$, with solution\n$u = \\Theta\\cos \\bar t$.\nThe period of these oscillations is $P=2\\pi$\nand the frequency is unity. The time\nfor simulation is taken as `num_periods` times $P$. The time step\nis set as $P$ divided by `time_steps_per_period`.\n\nThe `simulate` function should return the arrays of\n$x$, $y$, $\\theta$, and $t$, where $\\theta = \\tan^{-1}(x/(1-y))$ is\nthe angular displacement of the elastic pendulum corresponding to the\nposition $(x,y)$.\n\nIf `plot` is `True`, make a plot of $\\bar y(\\bar t)$\nversus $\\bar x(\\bar t)$, i.e., the physical motion\nof the mass at $(\\bar x,\\bar y)$. Use the equal aspect ratio on the axis\nsuch that we get a physically correct picture of the motion. Also\nmake a plot of $\\theta(\\bar t)$, where $\\theta$ is measured in degrees.\nIf $\\Theta < 10$ degrees, add a plot that compares the solutions of\nthe scaled, classical, non-elastic pendulum and the elastic pendulum\n($\\theta(t)$).\n\nAlthough the mathematics here employs a bar over scaled quantities, the\ncode should feature plain names `x` for $\\bar x$, `y` for $\\bar y$, and\n`t` for $\\bar t$ (rather than `x_bar`, etc.). These variable names make\nthe code easier to read and compare with the mathematics.\n\n\n\n**Hint 1.**\nEqual aspect ratio is set by `plt.gca().set_aspect('equal')` in\nMatplotlib (`import matplotlib.pyplot as plt`)\nand in SciTools by the command\n`plt.plot(..., daspect=[1,1,1], daspectmode='equal')`\n(provided you have done `import scitools.std as plt`).\n\n\n\n\n\n**Hint 2.**\nIf you want to use Odespy to solve the equations, order the ODEs\nlike $\\dot \\bar x, \\bar x, \\dot\\bar y,\\bar y$ such that\n`odespy.EulerCromer` can be applied.\n\n\n\n\n\n**Solution.**\nHere is a suggested `simulate` function:\n\n\n```python\nimport odespy\nimport numpy as np\nimport scitools.std as plt\n\ndef simulate(\n beta=0.9, # dimensionless parameter\n Theta=30, # initial angle in degrees\n epsilon=0, # initial stretch of wire\n num_periods=6, # simulate for num_periods\n time_steps_per_period=60, # time step resolution\n plot=True, # make plots or not\n ):\n from math import sin, cos, pi\n Theta = Theta*np.pi/180 # convert to radians\n # Initial position and velocity\n # (we order the equations such that Euler-Cromer in odespy\n # can be used, i.e., vx, x, vy, y)\n ic = [0, # x'=vx\n (1 + epsilon)*sin(Theta), # x\n 0, # y'=vy\n 1 - (1 + epsilon)*cos(Theta), # y\n ]\n\n def f(u, t, beta):\n vx, x, vy, y = u\n L = np.sqrt(x**2 + (y-1)**2)\n h = beta/(1-beta)*(1 - beta/L) # help factor\n return [-h*x, vx, -h*(y-1) - beta, vy]\n\n # Non-elastic pendulum (scaled similarly in the limit beta=1)\n # solution Theta*cos(t)\n P = 2*pi\n dt = P/time_steps_per_period\n T = num_periods*P\n omega = 2*pi/P\n\n time_points = np.linspace(\n 0, T, num_periods*time_steps_per_period+1)\n\n solver = odespy.EulerCromer(f, f_args=(beta,))\n solver.set_initial_condition(ic)\n u, t = solver.solve(time_points)\n x = u[:,1]\n y = u[:,3]\n theta = np.arctan(x/(1-y))\n\n if plot:\n plt.figure()\n plt.plot(x, y, 'b-', title='Pendulum motion',\n daspect=[1,1,1], daspectmode='equal',\n axis=[x.min(), x.max(), 1.3*y.min(), 1])\n plt.savefig('tmp_xy.png')\n plt.savefig('tmp_xy.pdf')\n # Plot theta in degrees\n plt.figure()\n plt.plot(t, theta*180/np.pi, 'b-',\n title='Angular displacement in degrees')\n plt.savefig('tmp_theta.png')\n plt.savefig('tmp_theta.pdf')\n if abs(Theta) < 10*pi/180:\n # Compare theta and theta_e for small angles (<10 degrees)\n theta_e = Theta*np.cos(omega*t) # non-elastic scaled sol.\n plt.figure()\n plt.plot(t, theta, t, theta_e,\n legend=['theta elastic', 'theta non-elastic'],\n title='Elastic vs non-elastic pendulum, '\\\n 'beta=%g' % beta)\n plt.savefig('tmp_compare.png')\n plt.savefig('tmp_compare.pdf')\n # Plot y vs x (the real physical motion)\n return x, y, theta, t\n```\n\n\n\n**b)**\nWrite a test function for testing that $\\Theta=0$ and $\\epsilon=0$\ngives $x=y=0$ for all times.\n\n\n\n**Solution.**\nHere is the code:\n\n\n```python\ndef test_equilibrium():\n \"\"\"Test that starting from rest makes x=y=theta=0.\"\"\"\n x, y, theta, t = simulate(\n beta=0.9, Theta=0, epsilon=0,\n num_periods=6, time_steps_per_period=10, plot=False)\n tol = 1E-14\n assert np.abs(x.max()) < tol\n assert np.abs(y.max()) < tol\n assert np.abs(theta.max()) < tol\n```\n\n\n\n**c)**\nWrite another test function for checking that the pure vertical\nmotion of the elastic pendulum is correct.\nStart with simplifying the ODEs for pure vertical motion and show that\n$\\bar y(\\bar t)$ fulfills a vibration equation with\nfrequency $\\sqrt{\\beta/(1-\\beta)}$. Set up the exact solution.\n\nWrite a test function that\nuses this special case to verify the `simulate` function. There will\nbe numerical approximation errors present in the results from\n`simulate` so you have to believe in correct results and set a\n(low) tolerance that corresponds to the computed maximum error.\nUse a small $\\Delta t$ to obtain a small numerical approximation error.\n\n\n\n**Solution.**\nFor purely vertical motion, the ODEs reduce to $\\ddot x = 0$ and\n\n$$\n\\frac{d^2\\bar y}{d\\bar t^2} = -\\frac{\\beta}{1-\\beta}(1-\\beta\\frac{1}{\\sqrt{(\\bar y - 1)^2}})(\\bar y-1) - \\beta = -\\frac{\\beta}{1-\\beta}(\\bar y-1 + \\beta) - \\beta\\thinspace .\n$$\n\nWe have here used that $(\\bar y -1)/\\sqrt{(\\bar y -1)^2}=-1$ since\n$\\bar y$ cannot exceed 1 (the pendulum's wire is fixed at the scaled\npoint $(0,1)$). In fact, $\\bar y$ will be around zero.\n(As a consistency check, we realize that in equilibrium, $\\ddot\\bar y =0$,\nand multiplying by $(1-\\beta)/\\beta$ leads to the expected $\\bar y=0$.)\nFurther calculations easily lead to\n\n$$\n\\frac{d^2\\bar y}{d\\bar t^2} = -\\frac{\\beta}{1-\\beta}\\bar y = -\\omega^2\\bar y,\n$$\n\nwhere we have introduced the frequency\n$\\omega = \\sqrt{\\beta/(1-\\beta)}$.\nSolving this standard ODE, with an initial stretching $\\bar y(0)=\\epsilon$\nand no velocity, results in\n\n$$\n\\bar y(\\bar t) = \\epsilon\\cos(\\omega\\bar t)\\thinspace .\n$$\n\nNote that the oscillations we describe here are very different from\nthe oscillations used to set the period and time step in function\n`simulate`. The latter type of oscillations are due to gravity when\na classical, non-elastic pendulum oscillates back and forth, while\n$\\bar y(\\bar t)$ above refers to vertical *elastic* oscillations in the wire\naround the equilibrium point in the gravity field. The angular frequency\nof the vertical oscillations are given by $\\omega$ and the corresponding\nperiod is $\\hat P = 2\\pi/\\omega$. Suppose we want to simulate for\n$T=N\\hat P = N2\\pi/\\omega$ and use $n$ time steps per period,\n$\\Delta\\bar t = \\hat P/n$. The `simulate` function operates with\na simulation time of `num_periods` times $2\\pi$. This means that we must set\n`num_periods=N/omega` if we want to simulate to time $T=N\\hat P$.\nThe parameter `time_steps_per_period` must be set to $\\omega n$\nsince `simulate` has $\\Delta t$ as $2\\pi$ divided by `time_steps_per_period`\nand we want $\\Delta t = 2\\pi\\omega^{-1}n^{-1}$.\n\nThe corresponding test function can be written as follows.\n\n\n```python\ndef test_vertical_motion():\n beta = 0.9\n omega = np.sqrt(beta/(1-beta))\n # Find num_periods. Recall that P=2*pi for scaled pendulum\n # oscillations, while here we don't have gravity driven\n # oscillations, but elastic oscillations with frequency omega.\n period = 2*np.pi/omega\n # We want T = N*period\n N = 5\n # simulate function has T = 2*pi*num_periods\n num_periods = 5/omega\n n = 600\n time_steps_per_period = omega*n\n\n y_exact = lambda t: -0.1*np.cos(omega*t)\n x, y, theta, t = simulate(\n beta=beta, Theta=0, epsilon=0.1,\n num_periods=num_periods,\n time_steps_per_period=time_steps_per_period,\n plot=False)\n\n tol = 0.00055 # ok tolerance for the above resolution\n # No motion in x direction is epxected\n assert np.abs(x.max()) < tol\n # Check motion in y direction\n y_e = y_exact(t)\n diff = np.abs(y_e - y).max()\n if diff > tol: # plot\n plt.plot(t, y, t, y_e, legend=['y', 'exact'])\n raw_input('Error in test_vertical_motion; type CR:')\n assert diff < tol, 'diff=%g' % diff\n```\n\n\n\n**d)**\nMake a function `demo(beta, Theta)` for simulating an elastic pendulum with a\ngiven $\\beta$ parameter and initial angle $\\Theta$. Use 600 time steps\nper period to get every accurate results, and simulate for 3 periods.\n\n\n\n**Solution.**\nThe `demo` function is just\n\n\n```python\ndef demo(beta=0.999, Theta=40, num_periods=3):\n x, y, theta, t = simulate(\n beta=beta, Theta=Theta, epsilon=0,\n num_periods=num_periods, time_steps_per_period=600,\n plot=True)\n```\n\nBelow are plots corresponding to $\\beta = 0.999$ (3 periods) and\n$\\beta = 0.93$ (one period):\n\n\n\n\n
\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n\n\nFilename: `elastic_pendulum`.\n\n\n\n\n\n\n\n\n## Exercise 6: Simulate an elastic pendulum with air resistance\n
\n\nThis is a continuation [Exercise 5: Simulate an elastic pendulum](#vib:exer:pendulum_elastic).\nAir resistance on the body with mass $m$ can be modeled by the\nforce $-\\frac{1}{2}\\varrho C_D A|\\v|\\v$,\nwhere $C_D$ is a drag coefficient (0.2 for a sphere), $\\varrho$\nis the density of air (1.2 $\\hbox{kg }\\,{\\hbox{m}}^{-3}$), $A$ is the\ncross section area ($A=\\pi R^2$ for a sphere, where $R$ is the radius),\nand $\\v$ is the velocity of the body.\nInclude air resistance in the original model, scale the model,\nwrite a function `simulate_drag` that is a copy of the `simulate`\nfunction from [Exercise 5: Simulate an elastic pendulum](#vib:exer:pendulum_elastic), but with the\nnew ODEs included, and show plots of how air resistance\ninfluences the motion.\n\n\n\n**Solution.**\nWe start with the model\n([18](#vib:app:pendulum_elastic:x))-([24](#vib:app:pendulum_elastic:vy0)).\nSince $\\v = \\dot x\\ii + \\dot y\\jj$, the air resistance term\ncan be written\n\n$$\n-q(\\dot x\\ii + \\dot y\\jj),\\quad q=\\frac{1}{2}\\varrho C_D A\\sqrt{\\dot x^2 + \\dot y^2}\\thinspace .\n$$\n\nNote that for positive velocities, the pendulum is moving to the right\nand the air resistance works against the motion, i.e., in direction of\n$-\\v = -\\dot x\\ii - \\dot y\\jj$.\n\nWe can easily include the terms in the ODEs:\n\n\n
\n\n$$\n\\begin{equation}\n\\ddot x = -\\frac{q}{m}\\dot x -\\frac{k}{m}\\left(1 -\\frac{L_0}{L}\\right)(x-x_0),\n\\label{vib:app:pendulum_elastic_drag:x} \\tag{44}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\ddot y = -\\frac{q}{m}\\dot y -\\frac{k}{m}\\left(1 -\\frac{L_0}{L}\\right)(y-y_0) - g,\n\\label{vib:app:pendulum_elastic_drag:y} \\tag{45}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \nL = \\sqrt{(x-x_0)^2 + (y-y_0)^2},\n\\label{vib:app:pendulum_elastic_drag:L} \\tag{46}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\label{_auto9} \\tag{47}\n\\end{equation}\n$$\n\nThe initial conditions are not affected.\n\nThe next step is to scale the model. We use the same scales as in\n[Exercise 5: Simulate an elastic pendulum](#vib:exer:pendulum_elastic), introduce $\\beta$, and $A=\\pi R^2$\nto simplify the $-q\\dot x/m$ term to\n\n$$\n\\frac{L_0}{2m}\\varrho C_D R^2\\beta^{-1}\n\\sqrt{\\left(\\frac{d\\bar x}{d\\bar t}\\right)^2 +\n\\left(\\frac{d\\bar y}{d\\bar t}\\right)^2}\n= \\gamma \\beta^{-1}\n\\sqrt{\\left(\\frac{d\\bar x}{d\\bar t}\\right)^2 +\n\\left(\\frac{d\\bar y}{d\\bar t}\\right)^2},\n$$\n\nwhere $\\gamma$ is a second dimensionless parameter:\n\n$$\n\\gamma = \\frac{L_0}{2m}\\varrho C_D R^2\\thinspace .\n$$\n\nThe final set of scaled equations is then\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d^2\\bar x}{d\\bar t^2} = -\\gamma\\beta^{-1}\n\\sqrt{\\left(\\frac{d\\bar x}{d\\bar t}\\right)^2 +\n\\left(\\frac{d\\bar y}{d\\bar t}\\right)^2}\\frac{d\\bar x}{d\\bar t}\n-\\frac{\\beta}{1-\\beta}\\left(1- \\frac{\\beta}{\\bar L}\\right)\\bar x,\n\\label{vib:app:pendulum_elastic_drag:x:s} \\tag{48}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d^2\\bar y}{d\\bar t^2} =\n-\\gamma\\beta^{-1}\n\\sqrt{\\left(\\frac{d\\bar x}{d\\bar t}\\right)^2 +\n\\left(\\frac{d\\bar y}{d\\bar t}\\right)^2}\\frac{d\\bar y}{d\\bar t}\n-\\frac{\\beta}{1-\\beta}\\left(1- \\frac{\\beta}{\\bar L}\\right)(\\bar y-1)\n-\\beta,\n\\label{vib:app:pendulum_elastic_drag:y:s} \\tag{49}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar L = \\sqrt{\\bar x^2 + (\\bar y-1)^2},\n\\label{vib:app:pendulum_elastic_drag:L:s} \\tag{50}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar x(0) = (1+\\epsilon)\\sin\\Theta,\n\\label{vib:app:pendulum_elastic_drag:x0:s} \\tag{51}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d\\bar x}{d\\bar t}(0) = 0,\n\\label{vib:app:pendulum_elastic_drag:vx0:s} \\tag{52}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\bar y(0) = 1 - (1+\\epsilon)\\cos\\Theta,\n\\label{vib:app:pendulum_elastic_drag:y0:s} \\tag{53}\n\\end{equation}\n$$\n\n\n
\n\n$$\n\\begin{equation} \n\\frac{d\\bar y}{d\\bar t}(0) = 0,\n\\label{vib:app:pendulum_elastic_drag:vy0:s} \\tag{54}\n\\end{equation}\n$$\n\nThe new `simulate_drag` function is implemented below.\n\n\n```python\ndef simulate_drag(\n beta=0.9, # dimensionless elasticity parameter\n gamma=0, # dimensionless drag parameter\n Theta=30, # initial angle in degrees\n epsilon=0, # initial stretch of wire\n num_periods=6, # simulate for num_periods\n time_steps_per_period=60, # time step resolution\n plot=True, # make plots or not\n ):\n from math import sin, cos, pi\n Theta = Theta*np.pi/180 # convert to radians\n # Initial position and velocity\n # (we order the equations such that Euler-Cromer in odespy\n # can be used, i.e., vx, x, vy, y)\n ic = [0, # x'=vx\n (1 + epsilon)*sin(Theta), # x\n 0, # y'=vy\n 1 - (1 + epsilon)*cos(Theta), # y\n ]\n\n def f(u, t, beta, gamma):\n vx, x, vy, y = u\n L = np.sqrt(x**2 + (y-1)**2)\n v = np.sqrt(vx**2 + vy**2)\n h1 = beta/(1-beta)*(1 - beta/L) # help factor\n h2 = gamma/beta*v\n return [-h2*vx - h1*x, vx, -h2*vy - h1*(y-1) - beta, vy]\n\n # Non-elastic pendulum (scaled similarly in the limit beta=1)\n # solution Theta*cos(t)\n P = 2*pi\n dt = P/time_steps_per_period\n T = num_periods*P\n omega = 2*pi/P\n\n time_points = np.linspace(\n 0, T, num_periods*time_steps_per_period+1)\n\n solver = odespy.EulerCromer(f, f_args=(beta, gamma))\n solver.set_initial_condition(ic)\n u, t = solver.solve(time_points)\n x = u[:,1]\n y = u[:,3]\n theta = np.arctan(x/(1-y))\n\n if plot:\n plt.figure()\n plt.plot(x, y, 'b-', title='Pendulum motion',\n daspect=[1,1,1], daspectmode='equal',\n axis=[x.min(), x.max(), 1.3*y.min(), 1])\n plt.savefig('tmp_xy.png')\n plt.savefig('tmp_xy.pdf')\n # Plot theta in degrees\n plt.figure()\n plt.plot(t, theta*180/np.pi, 'b-',\n title='Angular displacement in degrees')\n plt.savefig('tmp_theta.png')\n plt.savefig('tmp_theta.pdf')\n if abs(Theta) < 10*pi/180:\n # Compare theta and theta_e for small angles (<10 degrees)\n theta_e = Theta*np.cos(omega*t) # non-elastic scaled sol.\n plt.figure()\n plt.plot(t, theta, t, theta_e,\n legend=['theta elastic', 'theta non-elastic'],\n title='Elastic vs non-elastic pendulum, '\\\n 'beta=%g' % beta)\n plt.savefig('tmp_compare.png')\n plt.savefig('tmp_compare.pdf')\n # Plot y vs x (the real physical motion)\n return x, y, theta, t\n```\n\nThe plot of $\\theta$ shows the damping ($\\beta = 0.999$):\n\n\n\n\n
\n\n\n\n\n\nTest functions for equilibrium and vertical motion are also included. These\nare as in [Exercise 6: Simulate an elastic pendulum with air resistance](#vib:exer:pendulum_elastic_drag), except that\nthey call `simulate_drag` instead of `simulate`.\n\n\nFilename: `elastic_pendulum_drag`.\n\n\n\n### Remarks\n\nTest functions are challenging to construct for the problem with\nair resistance. You can reuse the tests from\n[Exercise 6: Simulate an elastic pendulum with air resistance](#vib:exer:pendulum_elastic_drag) for `simulate_drag`,\nbut these tests does not verify the new terms arising from air\nresistance.\n\n\n\n\n\n\n\n\n\n## Exercise 7: Implement the PEFRL algorithm\n
\n\nWe consider the motion of a planet around a star (the section [Two-body gravitational problem](#vib:app:gravitation)).\nThe simplified case where one\nmass is very much bigger than the other and one object is at rest,\nresults in the scaled ODE model\n\n$$\n\\begin{align*}\n\\ddot x + (x^2 + y^2)^{-3/2}x & = 0,\\\\ \n\\ddot y + (x^2 + y^2)^{-3/2}y & = 0\\thinspace .\n\\end{align*}\n$$\n\n**a)**\nmathcal{I}_t is easy to show that $x(t)$ and $y(t)$ go like sine and cosine\nfunctions. Use this idea to derive the exact solution.\n\n\n\n**Solution.**\nWe may assume $x=C_x\\cos(\\omega t)$ and $y=C_y\\sin(\\omega t)$ for\nconstants $C_x,$, $C_y$, and $\\omega$. Inserted in the equations, we\nsee that $\\omega =1$. The initial conditions determine the other\nconstants, which we may choose as $C_x=C_y=1$ (the object starts\nat $(1,0)$ with a velocity $(0,1)$). The motion is a perfect circle,\nwhich should last forever.\n\n\n\n**b)**\nOne believes that a planet may orbit a star for billions of years.\nWe are now interested\nin how accurate methods we actually need for such calculations.\nA first task is to determine what the time interval of interest is in\nscaled units. Take the earth and sun as typical objects and find\nthe characteristic time used in the scaling of the equations\n($t_c = \\sqrt{L^3/(mG)}$), where $m$ is the mass of the sun, $L$ is the\ndistance between the sun and the earth, and $G$ is the gravitational\nconstant. Find the scaled time interval corresponding to one billion years.\n\n\n\n**Solution.**\nAccording to [Wikipedia](https://en.wikipedia.org/wiki/Solar_mass),\nthe mass of the sun is approximately $2\\cdot 10^{30}$ kg. This\nis 332946 times the mass of the earth, implying that the\ndimensionless constant $\\alpha \\approx 3\\cdot 10^{-6}$. With\n$G=6.674\\cdot 10^{-11}\\hbox{ Nm}^2/\\hbox{kg}^2$, and the\n[sun-earth distance](https://en.wikipedia.org/wiki/Astronomical_unit)\nas (approximately) 150 million km, we have $t_c \\approx 5 028 388$ s.\nThis is about 58 days, which is the characteristic time, chosen as the\nangular frequency of the oscillations. To get the period of one orbit we therefore must multiply by $2\\pi$. This gives about 1 year (and demonstrates the\nfact mentioned about the scaling: the natural time scale is consistent with\nKepler's law about the period).\n\nThus, one billion years correspond to 62,715,924,070 time units (dividing\none billion years by $t_c$), which corresponds to about 2000\n\"time unit years\".\n\n\n\n**c)**\nSolve the equations using 4th-order Runge-Kutta and the Euler-Cromer\nmethods. You may benefit from applying Odespy for this purpose. With\neach solver, simulate 10000 orbits and print the maximum position\nerror and CPU time as a function of time step. Note that the maximum\nposition error does not necessarily occur at the end of the\nsimulation. The position error achieved with each solver will depend\nheavily on the size of the time step. Let the time step correspond to\n200, 400, 800 and 1600 steps per orbit, respectively. Are the results\nas expected? Explain briefly. When you develop your program, have in\nmind that it will be extended with an implementation of the other\nalgorithms (as requested in d) and e) later) and experiments with this\nalgorithm as well.\n\n\n\n**Solution.**\nThe first task is to implement the right-hand side function for the\nsystem of ODEs such that we can call up Odespy solvers (or make use of\nother types of ODE software, e.g., from SciPy). The $2\\times 2$ system of\nsecond-order ODEs must be expressed as a $4\\times 4$ system of first-order\nODEs. We have three different cases of right-hand sides:\n\n1. Common numbering of unknowns: $x$, $v_x$, $y$, $y_x$\n\n2. Numbering required by Euler-Cromer: $v_x$, $x$, $v_y$, $y$\n\n3. Numbering required by the PEFRL method: same as Euler-Cromer\n\nMost Odespy solvers can handle any convention for numbering of the unknowns.\nThe important point is that initial conditions and new values at the end of\nthe time step are filled in the right positions of a one-dimensional array\ncontaining the unknowns.\nUsing Odespy to solve the system by the Euler-Cromer method, however, requires\nthe unknowns to appear as velocity 1st degree-of-freedom, displacement\n1st degree-of-freedom, velocity 2nd degree-of-freedom, displacement\n2nd degree-of-freedom, and so forth. Two alternative right-hand side\nfunctions `f(u, t)` for Odespy solvers is then\n\n\n```python\ndef f_EC(u, t):\n '''\n Return derivatives for the 1st order system as\n required by Euler-Cromer.\n '''\n vx, x, vy, y = u # u: array holding vx, x, vy, y\n d = -(x**2 + y**2)**(-3.0/2)\n return [d*x, vx, d*y, vy ]\n\ndef f_RK4(u, t):\n '''\n Return derivatives for the 1st order system as\n required by ordinary solvers in Odespy.\n '''\n x, vx, y, vy = u # u: array holding x, vx, y, vy\n d = -(x**2 + y**2)**(-3.0/2)\n return [vx, d*x, vy, d*y ]\n```\n\nIn addition, we shall later in d) implement the PEFRL method and just\ngive the $g$ function as input to a system of the form $dv_x = g_x$,\n$dv_y = g_y$, and $g$ becomes the vector $(g_x,g_y)$:\n\nSome prefer to number the unknowns differently, and with the RK4 method we\nare free to use any numbering, including this one:\n\n\n```python\ndef g(u, v):\n return np.array([-u])\ndef u_exact(t):\n return np.array([3*np.cos(t)]).transpose()\nI = u_exact(0)\nV = np.array([0])\nprint 'V:', V, 'I:', I\n\n# Numerical parameters\nw = 1\nP = 2*np.pi/w\ndt_values = [P/20, P/40, P/80, P/160, P/320]\nT = 8*P\nerror_vs_dt = []\nfor n, dt in enumerate(dt_values):\n u, v, t = solver_PEFRL(I, V, g, dt, T)\n error = np.abs(u - u_exact(t)).max()\n print 'error:', error\n if n > 0:\n error_vs_dt.append(error/dt**4)\nfor i in range(1, len(error_vs_dt)):\n #print abs(error_vs_dt[i]- error_vs_dt[0])\n assert abs(error_vs_dt[i]-\n error_vs_dt[0]) < 0.1\n\n\ns PEFRL(odespy.Solver):\n\"\"\"Class wrapper for Odespy.\"\"\" # Not used!\nquick_desctiption = \"Explicit 4th-order method for v'=-f, u=v.\"\"\"\n\ndef advance(self):\n u, f, n, t = self.u, self.f, self.n, self.t\n dt = t[n+1] - t[n]\n I = np.array([u[1], u[3]])\n V = np.array([u[0], u[2]])\n u, v, t = solver_PFFRL(I, V, f, dt, t+dt)\n return np.array([v[-1], u[-1]])\n\ncompute_orbit_and_error(\nf,\nsolver_ID,\ntimesteps_per_period=20,\nN_orbit_groups=1000,\norbit_group_size=10):\n'''\nFor one particular solver:\nCalculte the orbits for a multiple of grouped orbits, i.e.\nnumber of orbits = orbit_group_size*N_orbit_groups.\nReturns: time step dt, and, for each N_orbit_groups cycle,\nthe 2D position error and cpu time (as lists).\n'''\ndef u_exact(t):\n return np.array([np.cos(t), np.sin(t)])\n\nw = 1\nP = 2*np.pi/w # scaled period (1 year becomes 2*pi)\ndt = P/timesteps_per_period\nNt = orbit_group_size*N_orbit_groups*timesteps_per_period\nT = Nt*dt\nt_mesh = np.linspace(0, T, Nt+1)\nE_orbit = []\n\n#print ' dt:', dt\nT_interval = P*orbit_group_size\nN = int(round(T_interval/dt))\n\n# set initial conditions\nif solver_ID == 'EC':\n A = [0,1,1,0]\nelif solver_ID == 'PEFRL':\n I = np.array([1, 0])\n V = np.array([0, 1])\nelse:\n A = [1,0,0,1]\n\nt1 = time.clock()\nfor i in range(N_orbit_groups):\n time_points = np.linspace(i*T_interval, (i+1)*T_interval,N+1)\n u_e = u_exact(time_points).transpose()\n if solver_ID == 'EC':\n solver = odespy.EulerCromer(f)\n solver.set_initial_condition(A)\n ui, ti = solver.solve(time_points)\n # Find error (correct final pos: x=1, y=0)\n orbit_error = np.sqrt(\n (ui[:,1]-u_e[:,0])**2 + (ui[:,3]-u_e[:,1])**2).max()\n elif solver_ID == 'PEFRL':\n # Note: every T_inverval is here counted from time 0\n ui, vi, ti = solver_PEFRL(I, V, f, dt, T_interval)\n # Find error (correct final pos: x=1, y=0)\n orbit_error = np.sqrt(\n (ui[:,0]-u_e[:,0])**2 + (ui[:,1]-u_e[:,1])**2).max()\n else:\n solver = eval('odespy.' + solver_ID(f)\n solver.set_initial_condition(A)\n ui, ti = solver.solve(time_points)\n # Find error (correct final pos: x=1, y=0)\n orbit_error = np.sqrt(\n (ui[:,0]-u_e[:,0])**2 + (ui[:,2]-u_e[:,1])**2).max()\n\n print ' Orbit no. %d, max error (per cent): %g' % \\\n ((i+1)*orbit_group_size, orbit_error)\n\n E_orbit.append(orbit_error)\n\n # set init. cond. for next time interval\n if solver_ID == 'EC':\n A = [ui[-1,0], ui[-1,1], ui[-1,2], ui[-1,3]]\n elif solver_ID == 'PEFRL':\n I = [ui[-1,0], ui[-1,1]]\n V = [vi[-1,0], vi[-1,1]]\n else: # RK4, adaptive rules, etc.\n A = [ui[-1,0], ui[-1,1], ui[-1,2], ui[-1,3]]\n\nt2 = time.clock()\nCPU_time = (t2 - t1)/(60.0*60.0) # in hours\nreturn dt, E_orbit, CPU_time\n\norbit_error_vs_dt(\nf_EC, f_RK4, g, solvers,\nN_orbit_groups=1000,\norbit_group_size=10):\n'''\nWith each solver in list \"solvers\": Simulate\norbit_group_size*N_orbit_groups orbits with different dt values.\nCollect final 2D position error for each dt and plot all errors.\n'''\n\nfor solver_ID in solvers:\n print 'Computing orbit with solver:', solver_ID\n E_values = []\n dt_values = []\n cpu_values = []\n for timesteps_per_period in 200, 400, 800, 1600:\n print '.......time steps per period: ', \\\n timesteps_per_period\n if solver_ID == 'EC':\n dt, E, cpu_time = compute_orbit_and_error(\n f_EC,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n elif solver_ID == 'PEFRL':\n dt, E, cpu_time = compute_orbit_and_error(\n g,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n else:\n dt, E, cpu_time = compute_orbit_and_error(\n f_RK4,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n\n dt_values.append(dt)\n E_values.append(np.array(E).max())\n cpu_values.append(cpu_time)\n print 'dt_values:', dt_values\n print 'E max with dt...:', E_values\n print 'cpu_values with dt...:', cpu_values\n\n\norbit_error_vs_years(\nf_EC, f_RK4, g, solvers,\nN_orbit_groups=1000,\norbit_group_size=100,\nN_time_steps = 1000):\n'''\nFor each solver in the list solvers:\nsimulate orbit_group_size*N_orbit_groups orbits with a fixed\ndt corresponding to N_time_steps steps per year.\nCollect max 2D position errors for each N_time_steps'th run,\nplot these errors and CPU. Finally, make an empirical\nformula for error and CPU as functions of a number\nof cycles.\n'''\ntimesteps_per_period = N_time_steps # fixed for all runs\n\nfor solver_ID in solvers:\n print 'Computing orbit with solver:', solver_ID\n if solver_ID == 'EC':\n dt, E, cpu_time = compute_orbit_and_error(\n f_EC,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n elif solver_ID == 'PEFRL':\n dt, E, cpu_time = compute_orbit_and_error(\n g,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n else:\n dt, E, cpu_time = compute_orbit_and_error(\n f_RK4,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n\n # E and cpu_time are for every N_orbit_groups cycle\n print 'E_values (fixed dt, changing no of years):', E\n print 'CPU (hours):', cpu_time\n years = np.arange(\n 0,\n N_orbit_groups*orbit_group_size,\n orbit_group_size)\n\n # Now make empirical formula\n\n def E_of_years(x, *coeff):\n return sum(coeff[i]*x**float((len(coeff)-1)-i) \\\n for i in range(len(coeff)))\n E = np.array(E)\n degree = 4\n # note index: polyfit finds p[0]*x**4 + p[1]*x**3 ...etc.\n p = np.polyfit(years, E, degree)\n p_str = map(str, p)\n formula = ' + '.join([p_str[i] + '*x**' + \\\n str(degree-i) for i in range(degree+1)])\n\n print 'Empirical formula (error with years): ', formula\n plt.figure()\n plt.plot(years,\n E, 'b-',\n years,\n E_of_years(years, *p), 'r--')\n plt.xlabel('Number of years')\n plt.ylabel('Orbit error')\n plt.title(solver_ID)\n filename = solver_ID + 'tmp_E_with_years'\n plt.savefig(filename + '.png')\n plt.savefig(filename + '.pdf')\n plt.show()\n\n print 'Predicted CPU time in hours (1 billion years):', \\\n cpu_time*10000\n print 'Predicted max error (1 billion years):', \\\n E_of_years(1E9, *p)\n\ncompute_orbit_error_and_CPU():\n'''\nOrbit error and associated CPU times are computed with\nsolvers: RK4, Euler-Cromer, PEFRL.'''\n\ndef f_EC(u, t):\n '''\n Return derivatives for the 1st order system as\n required by Euler-Cromer.\n '''\n vx, x, vy, y = u # u: array holding vx, x, vy, y\n d = -(x**2 + y**2)**(-3.0/2)\n return [d*x, vx, d*y, vy ]\n\ndef f_RK4(u, t):\n '''\n Return derivatives for the 1st order system as\n required by ordinary solvers in Odespy.\n '''\n x, vx, y, vy = u # u: array holding x, vx, y, vy\n d = -(x**2 + y**2)**(-3.0/2)\n return [vx, d*x, vy, d*y ]\n\ndef g(u, v):\n '''\n Return derivatives for the 1st order system as\n required by PEFRL.\n '''\n d = -(u[0]**2 + u[1]**2)**(-3.0/2)\n return np.array([d*u[0], d*u[1]])\n```\n\nThe standard way of solving the ODE by Odespy is then\n\n\n```python\ndef u_exact(t):\n \"\"\"Return exact solution at time t.\"\"\"\n return np.array([np.cos(t), np.sin(t)])\n\nu_e = u_exact(time_points).transpose()\n\nsolver = odespy.RK4(f_RK4)\nsolver.set_initial_condition(A)\nui, ti = solver.solve(time_points)\n\n# Find error (correct final pos: x=1, y=0)\norbit_error = np.sqrt(\n (ui[:,0]-u_e[:,0])**2 + (ui[:,2]-u_e[:,1])**2).max()\n```\n\nWe develop functions for computing errors and plotting results where we\ncan compare different methods. These functions are shown in the solution to\nitem d).\n\nRunning the code, the time step sizes become\n\n dt_values: [0.031415926535897934, 0.015707963267948967,\n 0.007853981633974483, 0.003926990816987242]\n\n\nCorresponding maximum errors (per cent) and CPU values (hours) are for the 4th-order Runge-Kutta given in the table below.\n\n\n\n Quantity $\\Delta t_1$ $\\Delta t_2$ $\\Delta t_3$ $\\Delta t_4$ \n\n $\\Delta t$ 0.03 0.02 0.008 0.004 Error 1.9039 0.0787 0.0025 7.7e-05 CPU (h) 0.03 0.06 0.12 0.23 \n
\nFor Euler-Cromer we these results:\n\n\n\n Quantity $\\Delta t_1$ $\\Delta t_2$ $\\Delta t_3$ $\\Delta t_4$ \n\n $\\Delta t$ 0.03 0.02 0.008 0.004 Error 2.0162 2.0078 1.9634 0.6730 CPU (h) 0.01 0.02 0.05 0.09 \n
\n\nThese results are as expected. The Runge-Kutta implementation is much more accurate than Euler-Cromer, but since it requires more computations, more CPU time is needed. For both methods, accuracy and CPU time both increase as\nthe step size is reduced, but the increase is much more pronounced for\nthe Euler-Cromer method.\n\n\n\n**d)**\nImplement a solver based on the PEFRL method from\nthe section [vib:ode2:PEFRL](#vib:ode2:PEFRL). Verify its 4th-order convergence\nusing an equation $u'' + u = 0$.\n\n\n\n**Solution.**\nHere is a solver function:\n\n\n```python\nimport numpy as np\nimport time\n\ndef solver_PEFRL(I, V, g, dt, T):\n \"\"\"\n Solve v' = - g(u,v), u'=v for t in (0,T], u(0)=I and v(0)=V,\n by the PEFRL method.\n \"\"\"\n dt = float(dt)\n Nt = int(round(T/dt))\n u = np.zeros((Nt+1, len(I)))\n v = np.zeros((Nt+1, len(I)))\n t = np.linspace(0, Nt*dt, Nt+1)\n\n # these values are from eq (20), ref to paper below\n xi = 0.1786178958448091\n lambda_ = -0.2123418310626054\n chi = -0.06626458266981849\n\n v[0] = V\n u[0] = I\n # Compare with eq 22 in http://arxiv.org/pdf/cond-mat/0110585.pdf\n for n in range(0, Nt):\n u_ = u[n] + xi*dt*v[n]\n v_ = v[n] + 0.5*(1-2*lambda_)*dt*g(u_, v[n])\n u_ = u_ + chi*dt*v_\n v_ = v_ + lambda_*dt*g(u_, v_)\n u_ = u_ + (1-2*(chi+xi))*dt*v_\n v_ = v_ + lambda_*dt*g(u_, v_)\n u_ = u_ + chi*dt*v_\n v[n+1] = v_ + 0.5*(1-2*lambda_)*dt*g(u_, v_)\n u[n+1] = u_ + xi*dt*v[n+1]\n #print 'v[%d]=%g, u[%d]=%g' % (n+1,v[n+1],n+1,u[n+1])\n return u, v, t\n```\n\nA proper test function for verification reads\n\n\n```python\ndef test_solver_PEFRL():\n \"\"\"Check 4th order convergence rate, using u'' + u = 0,\n I = 3.0, V = 0, which has the exact solution u_e = 3*cos(t)\"\"\"\n def g(u, v):\n return np.array([-u])\n def u_exact(t):\n return np.array([3*np.cos(t)]).transpose()\n I = u_exact(0)\n V = np.array([0])\n print 'V:', V, 'I:', I\n\n # Numerical parameters\n w = 1\n P = 2*np.pi/w\n dt_values = [P/20, P/40, P/80, P/160, P/320]\n T = 8*P\n error_vs_dt = []\n for n, dt in enumerate(dt_values):\n u, v, t = solver_PEFRL(I, V, g, dt, T)\n error = np.abs(u - u_exact(t)).max()\n print 'error:', error\n if n > 0:\n error_vs_dt.append(error/dt**4)\n for i in range(1, len(error_vs_dt)):\n #print abs(error_vs_dt[i]- error_vs_dt[0])\n assert abs(error_vs_dt[i]-\n error_vs_dt[0]) < 0.1\n```\n\n\n\n**e)**\nThe simulations done previously with the 4th-order Runge-Kutta and\nEuler-Cromer are now to be repeated with the PEFRL solver, so the\ncode must be extended accordingly. Then run the simulations and comment\non the performance of PEFRL compared to the other two.\n\n\n\n**Solution.**\nWith the PEFRL algorithm, we get\n\n E max with dt...: [0.0010452575786173163, 6.5310955829464402e-05,\n 4.0475768394248492e-06, 2.9391302503251016e-07]\n cpu_values with dt...: [0.01873611111111106, 0.037422222222222294,\n 0.07511666666666655, 0.14985]\n\n\n\n\n Qantity $\\Delta t_1$ $\\Delta t_2$ $\\Delta t_3$ $\\Delta t_4$ \n\n $\\Delta t$ 0.03 0.02 0.008 0.004 Error 1.04E-3 6.53E-05 4.05E-6 2.94E-7 CPU (h) 0.02 0.04 0.08 0.15 \n
\n\nThe accuracy is now dramatically improved compared to 4th-order Runge-Kutta (and Euler-Cromer).\nWith 1600 steps per orbit, the PEFRL maximum error is just below $3.0e-07$ per cent, while\nthe corresponding error with Runge-Kutta was about $7.7e-05$ per cent! This is striking,\nconsidering the fact that the 4th-order Runge-Kutta and the PEFRL schemes are both 4th-order accurate.\n\n\n\n**f)**\nUse the PEFRL solver to simulate 100000 orbits with a fixed time step\ncorresponding to 1600 steps per period. Record the maximum error\nwithin each subsequent group of 1000 orbits. Plot these errors and fit\n(least squares) a mathematical function to the data. Print also the\ntotal CPU time spent for all 100000 orbits.\n\nNow, predict the error and required CPU time for a simulation of 1\nbillion years (orbits). Is it feasible on today's computers to\nsimulate the planetary motion for one billion years?\n\n\n\n**Solution.**\nThe complete code (which also produces the printouts given previously) reads:\n\n\n```python\nimport scitools.std as plt\nimport sys\nimport odespy\nimport numpy as np\nimport time\n\ndef solver_PEFRL(I, V, g, dt, T):\n \"\"\"\n Solve v' = - g(u,v), u'=v for t in (0,T], u(0)=I and v(0)=V,\n by the PEFRL method.\n \"\"\"\n dt = float(dt)\n Nt = int(round(T/dt))\n u = np.zeros((Nt+1, len(I)))\n v = np.zeros((Nt+1, len(I)))\n t = np.linspace(0, Nt*dt, Nt+1)\n\n # these values are from eq (20), ref to paper below\n xi = 0.1786178958448091\n lambda_ = -0.2123418310626054\n chi = -0.06626458266981849\n\n v[0] = V\n u[0] = I\n # Compare with eq 22 in http://arxiv.org/pdf/cond-mat/0110585.pdf\n for n in range(0, Nt):\n u_ = u[n] + xi*dt*v[n]\n v_ = v[n] + 0.5*(1-2*lambda_)*dt*g(u_, v[n])\n u_ = u_ + chi*dt*v_\n v_ = v_ + lambda_*dt*g(u_, v_)\n u_ = u_ + (1-2*(chi+xi))*dt*v_\n v_ = v_ + lambda_*dt*g(u_, v_)\n u_ = u_ + chi*dt*v_\n v[n+1] = v_ + 0.5*(1-2*lambda_)*dt*g(u_, v_)\n u[n+1] = u_ + xi*dt*v[n+1]\n #print 'v[%d]=%g, u[%d]=%g' % (n+1,v[n+1],n+1,u[n+1])\n return u, v, t\n\ndef test_solver_PEFRL():\n \"\"\"Check 4th order convergence rate, using u'' + u = 0,\n I = 3.0, V = 0, which has the exact solution u_e = 3*cos(t)\"\"\"\n def g(u, v):\n return np.array([-u])\n def u_exact(t):\n return np.array([3*np.cos(t)]).transpose()\n I = u_exact(0)\n V = np.array([0])\n print 'V:', V, 'I:', I\n\n # Numerical parameters\n w = 1\n P = 2*np.pi/w\n dt_values = [P/20, P/40, P/80, P/160, P/320]\n T = 8*P\n error_vs_dt = []\n for n, dt in enumerate(dt_values):\n u, v, t = solver_PEFRL(I, V, g, dt, T)\n error = np.abs(u - u_exact(t)).max()\n print 'error:', error\n if n > 0:\n error_vs_dt.append(error/dt**4)\n for i in range(1, len(error_vs_dt)):\n #print abs(error_vs_dt[i]- error_vs_dt[0])\n assert abs(error_vs_dt[i]-\n error_vs_dt[0]) < 0.1\n\n\nclass PEFRL(odespy.Solver):\n \"\"\"Class wrapper for Odespy.\"\"\" # Not used!\n quick_desctiption = \"Explicit 4th-order method for v'=-f, u=v.\"\"\"\n\n def advance(self):\n u, f, n, t = self.u, self.f, self.n, self.t\n dt = t[n+1] - t[n]\n I = np.array([u[1], u[3]])\n V = np.array([u[0], u[2]])\n u, v, t = solver_PFFRL(I, V, f, dt, t+dt)\n return np.array([v[-1], u[-1]])\n\ndef compute_orbit_and_error(\n f,\n solver_ID,\n timesteps_per_period=20,\n N_orbit_groups=1000,\n orbit_group_size=10):\n '''\n For one particular solver:\n Calculte the orbits for a multiple of grouped orbits, i.e.\n number of orbits = orbit_group_size*N_orbit_groups.\n Returns: time step dt, and, for each N_orbit_groups cycle,\n the 2D position error and cpu time (as lists).\n '''\n def u_exact(t):\n return np.array([np.cos(t), np.sin(t)])\n\n w = 1\n P = 2*np.pi/w # scaled period (1 year becomes 2*pi)\n dt = P/timesteps_per_period\n Nt = orbit_group_size*N_orbit_groups*timesteps_per_period\n T = Nt*dt\n t_mesh = np.linspace(0, T, Nt+1)\n E_orbit = []\n\n #print ' dt:', dt\n T_interval = P*orbit_group_size\n N = int(round(T_interval/dt))\n\n # set initial conditions\n if solver_ID == 'EC':\n A = [0,1,1,0]\n elif solver_ID == 'PEFRL':\n I = np.array([1, 0])\n V = np.array([0, 1])\n else:\n A = [1,0,0,1]\n\n t1 = time.clock()\n for i in range(N_orbit_groups):\n time_points = np.linspace(i*T_interval, (i+1)*T_interval,N+1)\n u_e = u_exact(time_points).transpose()\n if solver_ID == 'EC':\n solver = odespy.EulerCromer(f)\n solver.set_initial_condition(A)\n ui, ti = solver.solve(time_points)\n # Find error (correct final pos: x=1, y=0)\n orbit_error = np.sqrt(\n (ui[:,1]-u_e[:,0])**2 + (ui[:,3]-u_e[:,1])**2).max()\n elif solver_ID == 'PEFRL':\n # Note: every T_inverval is here counted from time 0\n ui, vi, ti = solver_PEFRL(I, V, f, dt, T_interval)\n # Find error (correct final pos: x=1, y=0)\n orbit_error = np.sqrt(\n (ui[:,0]-u_e[:,0])**2 + (ui[:,1]-u_e[:,1])**2).max()\n else:\n solver = eval('odespy.' + solver_ID(f)\n solver.set_initial_condition(A)\n ui, ti = solver.solve(time_points)\n # Find error (correct final pos: x=1, y=0)\n orbit_error = np.sqrt(\n (ui[:,0]-u_e[:,0])**2 + (ui[:,2]-u_e[:,1])**2).max()\n\n print ' Orbit no. %d, max error (per cent): %g' % \\\n ((i+1)*orbit_group_size, orbit_error)\n\n E_orbit.append(orbit_error)\n\n # set init. cond. for next time interval\n if solver_ID == 'EC':\n A = [ui[-1,0], ui[-1,1], ui[-1,2], ui[-1,3]]\n elif solver_ID == 'PEFRL':\n I = [ui[-1,0], ui[-1,1]]\n V = [vi[-1,0], vi[-1,1]]\n else: # RK4, adaptive rules, etc.\n A = [ui[-1,0], ui[-1,1], ui[-1,2], ui[-1,3]]\n\n t2 = time.clock()\n CPU_time = (t2 - t1)/(60.0*60.0) # in hours\n return dt, E_orbit, CPU_time\n\ndef orbit_error_vs_dt(\n f_EC, f_RK4, g, solvers,\n N_orbit_groups=1000,\n orbit_group_size=10):\n '''\n With each solver in list \"solvers\": Simulate\n orbit_group_size*N_orbit_groups orbits with different dt values.\n Collect final 2D position error for each dt and plot all errors.\n '''\n\n for solver_ID in solvers:\n print 'Computing orbit with solver:', solver_ID\n E_values = []\n dt_values = []\n cpu_values = []\n for timesteps_per_period in 200, 400, 800, 1600:\n print '.......time steps per period: ', \\\n timesteps_per_period\n if solver_ID == 'EC':\n dt, E, cpu_time = compute_orbit_and_error(\n f_EC,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n elif solver_ID == 'PEFRL':\n dt, E, cpu_time = compute_orbit_and_error(\n g,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n else:\n dt, E, cpu_time = compute_orbit_and_error(\n f_RK4,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n\n dt_values.append(dt)\n E_values.append(np.array(E).max())\n cpu_values.append(cpu_time)\n print 'dt_values:', dt_values\n print 'E max with dt...:', E_values\n print 'cpu_values with dt...:', cpu_values\n\n\ndef orbit_error_vs_years(\n f_EC, f_RK4, g, solvers,\n N_orbit_groups=1000,\n orbit_group_size=100,\n N_time_steps = 1000):\n '''\n For each solver in the list solvers:\n simulate orbit_group_size*N_orbit_groups orbits with a fixed\n dt corresponding to N_time_steps steps per year.\n Collect max 2D position errors for each N_time_steps'th run,\n plot these errors and CPU. Finally, make an empirical\n formula for error and CPU as functions of a number\n of cycles.\n '''\n timesteps_per_period = N_time_steps # fixed for all runs\n\n for solver_ID in solvers:\n print 'Computing orbit with solver:', solver_ID\n if solver_ID == 'EC':\n dt, E, cpu_time = compute_orbit_and_error(\n f_EC,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n elif solver_ID == 'PEFRL':\n dt, E, cpu_time = compute_orbit_and_error(\n g,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n else:\n dt, E, cpu_time = compute_orbit_and_error(\n f_RK4,\n solver_ID,\n timesteps_per_period,\n N_orbit_groups,\n orbit_group_size)\n\n # E and cpu_time are for every N_orbit_groups cycle\n print 'E_values (fixed dt, changing no of years):', E\n print 'CPU (hours):', cpu_time\n years = np.arange(\n 0,\n N_orbit_groups*orbit_group_size,\n orbit_group_size)\n\n # Now make empirical formula\n\n def E_of_years(x, *coeff):\n return sum(coeff[i]*x**float((len(coeff)-1)-i) \\\n for i in range(len(coeff)))\n E = np.array(E)\n degree = 4\n # note index: polyfit finds p[0]*x**4 + p[1]*x**3 ...etc.\n p = np.polyfit(years, E, degree)\n p_str = map(str, p)\n formula = ' + '.join([p_str[i] + '*x**' + \\\n str(degree-i) for i in range(degree+1)])\n\n print 'Empirical formula (error with years): ', formula\n plt.figure()\n plt.plot(years,\n E, 'b-',\n years,\n E_of_years(years, *p), 'r--')\n plt.xlabel('Number of years')\n plt.ylabel('Orbit error')\n plt.title(solver_ID)\n filename = solver_ID + 'tmp_E_with_years'\n plt.savefig(filename + '.png')\n plt.savefig(filename + '.pdf')\n plt.show()\n\n print 'Predicted CPU time in hours (1 billion years):', \\\n cpu_time*10000\n print 'Predicted max error (1 billion years):', \\\n E_of_years(1E9, *p)\n\ndef compute_orbit_error_and_CPU():\n '''\n Orbit error and associated CPU times are computed with\n solvers: RK4, Euler-Cromer, PEFRL.'''\n\n def f_EC(u, t):\n '''\n Return derivatives for the 1st order system as\n required by Euler-Cromer.\n '''\n vx, x, vy, y = u # u: array holding vx, x, vy, y\n d = -(x**2 + y**2)**(-3.0/2)\n return [d*x, vx, d*y, vy ]\n\n def f_RK4(u, t):\n '''\n Return derivatives for the 1st order system as\n required by ordinary solvers in Odespy.\n '''\n x, vx, y, vy = u # u: array holding x, vx, y, vy\n d = -(x**2 + y**2)**(-3.0/2)\n return [vx, d*x, vy, d*y ]\n\n def g(u, v):\n '''\n Return derivatives for the 1st order system as\n required by PEFRL.\n '''\n d = -(u[0]**2 + u[1]**2)**(-3.0/2)\n return np.array([d*u[0], d*u[1]])\n\n print 'Find orbit error as fu. of dt...(10000 orbits)'\n solvers = ['RK4', 'EC', 'PEFRL']\n N_orbit_groups=1\n orbit_group_size=10000\n orbit_error_vs_dt(\n f_EC, f_RK4, g, solvers,\n N_orbit_groups=N_orbit_groups,\n orbit_group_size=orbit_group_size)\n\n print 'Compute orbit error as fu. of no of years (fixed dt)...'\n solvers = ['PEFRL']\n N_orbit_groups=100\n orbit_group_size=1000\n N_time_steps = 1600 # no of steps per orbit cycle\n orbit_error_vs_years(\n f_EC, f_RK4, g, solvers,\n N_orbit_groups=N_orbit_groups,\n orbit_group_size=orbit_group_size,\n N_time_steps = N_time_steps)\n\nif __name__ == '__main__':\n test_solver_PEFRL()\n compute_orbit_error_and_CPU()\n```\n\nThe maximum error develops with number of orbits as seen in the following plot,\nwhere the red dashed curve is from the mathematical model:\n\n\n\n\n
\n\n\n\n\n\nWe note that the maximum error achieved during the first 100000 orbits is only\nabout $1.2e-06$ per cent. Not bad!\n\nFor the printed CPU and empirical formula, we get:\n\n CPU (hours): 1.51591388889\n Empirical formula (E with years):\n 3.15992325978e-26*x**4 + -6.1772567063e-21*x**3 +\n 1.87983349496e-16*x**2 + 2.32924158693e-11*x**1 +\n 5.46989368301e-08*x**0\n\n\nSince the CPU develops linearly, the CPU time for 100000 orbits can just be multiplied by 10000 to get the\nestimated CPU time required for 1 billion years. This gives 15159 CPU hours (631 days), which is also printed.\n\nWith the derived empirical formula, the estimated orbit error after 1 billion years becomes 31593055529 per cent.\n\n[sl 2: Can we really use the plot and the function to predict max E during 1 billion years? Seems hard.]\n\n\n\nFilename: `vib_PEFRL`.\n\n\n\n### Remarks\n\nThis exercise investigates whether it is feasible to predict\nplanetary motion for the life time of a solar system.\n[hpl 3: Is it???]\n\n\n\n", "meta": {"hexsha": "4c2878f072bbb9ed69c397496d8d88637987ccf2", "size": 183797, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "fdm-devito-notebooks/01_vib/vib_app.ipynb", "max_stars_repo_name": "devitocodes/devito_book", "max_stars_repo_head_hexsha": "30405c3d440a1f89df69594fd0704f69650c1ded", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 7, "max_stars_repo_stars_event_min_datetime": "2020-07-17T13:19:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-27T05:21:09.000Z", "max_issues_repo_path": "fdm-devito-notebooks/01_vib/vib_app.ipynb", "max_issues_repo_name": "devitocodes/devito_book", "max_issues_repo_head_hexsha": "30405c3d440a1f89df69594fd0704f69650c1ded", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 73, "max_issues_repo_issues_event_min_datetime": "2020-07-14T15:38:52.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-25T11:54:59.000Z", "max_forks_repo_path": "fdm-devito-notebooks/01_vib/vib_app.ipynb", "max_forks_repo_name": "devitocodes/devito_book", "max_forks_repo_head_hexsha": "30405c3d440a1f89df69594fd0704f69650c1ded", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-27T05:21:14.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-27T05:21:14.000Z", "avg_line_length": 33.6871334311, "max_line_length": 246, "alphanum_fraction": 0.5159931881, "converted": true, "num_tokens": 38219, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38861801254413975, "lm_q2_score": 0.31405055141190724, "lm_q1q2_score": 0.12204570112808658}}
{"text": "###### Content under Creative Commons Attribution license CC-BY 4.0, code under BSD 3-Clause License © 2019 by D. Koehn, notebook style sheet by L.A. Barba, N.C. Clementi\n\n\n```python\n# Execute this cell to load the notebook's style sheet, then ignore it\nfrom IPython.core.display import HTML\ncss_file = '../style/custom.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n\nRównaniem nieliniowym nazywa się równanie w którym jedna lub więcej zmiennych występuje nieliniowo, np. funkcje trygonometryczne lub wielomian trzeciego stopnia. Rozwiązywanie takich równań(funkcji) polega na znajdowaniu takiego x dla którego f(x) = 0. Na tym laboratorium będą omawianie iteracyjne metody rozwiązywania takich równań, czyli takie które z każdą kolejną iteracją (krokiem), są coraz bliżej rozwiązania. Pierwszym krokiem przy iteracyjnym rozwiązywaniu zadań, jest upewnienie się że dane równanie posiada miejsce zerowe. Następnym krokiem jest wybór odpowiedniego algorytmu. Kolejnym krokiem jest wybór warunku stopu, czyli określenie jakie przybliżenie jest dla nas zadowalające i można przerwać iterację. Istnieją na to trzy sposoby: \n
\n\n\n* grube stopowanie na osi OY: \n\n\\begin{equation}\n |f(x_n)| < tol_{1}\n\\end{equation}\n\n\n* grube stopowanie na osi OX:\n\n\\begin{equation}\n|x_n - x_{n-1}| < tol_{2}\n\\end{equation}\n\n\n* drugi sposób i sprawdzanie zmiany pomiędzy dwoma kolejnymi przybliżeniami:\n\n\\begin{equation}\n|x_n - x_{n-1}| < tol_{2} \\wedge |x_{n} - x_{n-1}| \\leq |x_{n-1} - x_{n-2}|\n\\end{equation}\n\nPierwszy z nich i zarazem najbardziej naiwny, sprawdza odległość pomiędzy wartością funkcji w wyznaczonym przybliżeniu a dokładnością, która jest bardzo bliska zeru. Drugi sposób porównuje odległość pomiędzy dwoma kolejnymi przybliżeniami pierwiastka, natomiast trzeci jest rozszerzeniem drugiego warunku - dodatkowo sprawdzana jest różnica pomiędzy dwoma ostatnimi przybliżeniami. Trzeci warunek może być stosowany tylko dla metod rekurencyjnych. W ćwiczeniach będzie stosowany pierwszy warunek, gdyż można go zastosować do wszystkich omawianych algorytmów.\n
\n\n\n\n## Przykład 1. Rozwiązywanie równań nieliniowych \nDo rozwiązywania równań nieliniowych (m.in.) służą pakiety SciPy oraz SymPy. Pierwszy z nich służy do obliczeń numerycznych, drugi natomiast do symbolicznych. Najpopularniejszą funkcją z pierwszego pakietu która rozwiązuje równania jest funkcja fsolve . Jako argumenty funkcja ta przyyjmuje funkcję w postaci wielomianiu, oraz tablicę pierwszych przybliżeń. Metodę tą można stosować zarówno dla pojedynczych równań jak ich układów. Funkcja ta jest wrapperem dla zdefiniowanych w pakiecie MINPACK algorytmów hybrd oraz hybrj . Poniżej przedstawiono przykład jej użycia. \n
\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n\nfrom numpy import sign\nfrom scipy.optimize import fsolve \n\n# rozwiązywanie pojedyńczego równania kwadratowego x^2 + x - 5 = 0, \n# posiadającego dwa pierwiastki\nfun = lambda x: x ** 2 + x - 5\n\n# tablica pierwszych przybliżeń\nxguess = [-4, 2]\n\nroots = fsolve(fun, xguess)\ny = fun(roots)\n\nprint(f\"x = {roots} \\ny = {y}\")\n\n# sprawdzenie czy wartości y obliczonych pierwiastków są bliskie 0\nprint(np.isclose(y, [0.0, 0.0]))\n```\n\n x = [-2.79128785 1.79128785] \n y = [0.0000000e+00 8.8817842e-16]\n [ True True]\n\n\n## Przykład 2. Krótko o pandas \nPandas to biblioteka, powszechnie używana w szeroko rozumianym data science. Udostępnia ona zestaw narzędzi do analizy i obróbki danych, z których najbardziej znanym jest klasa DataFrame - dwuwymiarowa tablica do przechowywania danych. \n\n\n* klasa Series
\n\n## Ćwiczenie 1 \nNapisz funkcję $fun1$ będącą implementacją wzoru\n\\begin{equation}\nf(x) = x^3+x^2-3x-3\n\\tag{1}\n\\end{equation}\n\n\nDo rozwiązania tego punktu można użyć operatora potęgowania **\\*\\***, a sam wzór zdefiniować jako zwyczajną
funkcję lub wyrażenie
lambda .\n
\nMetoda ta polega na iteracyjnym wyznaczaniu coraz mniejszych przedziałów, co do których mamy pewność, że zawierają zero funkcji. Załóżmy, że dana jest funkcja $f(x)$, która jest ciągła w przedziale $[a,b]$ i przyjmuje na jego brzegach wartości o przeciwnych znakach ($f(a)f(b)<0$). W takim przypadku przedział $[a,b]$ musi zawierać pierwiastek funkcji. Za przybliżone rozwiązanie możemy uznać punkt leżący w środku przedziału $[a,b]$, czyli:\n\n\\begin{equation}\nc = \\frac{a+b}{2}\n\\tag{2}\n\\end{equation}\n
\n\nW przypadku gdy $f(c)=0$ miejsce zerowe zostało odnalezione. Z reguły jednak $f(c) \\neq 0$ i poszukiwania trzeba kontynuować. Zero będzie znajdować się albo w przedziale $[a,c]$, albo w przedziale $[c,b]$. Aby wybrać właściwy przedział wystarczy sprawdzić wartość funkcji w punkcie $c$. Jeśli $f(a)f(c)<0$ kontynuujemy proces w przedziale $[a,c]$, jeśli $f(c)f(b)<0$ oznacza to, że w następnej iteracji wartość $c$ będzie trzeba podstawić w miejsce $a$. Iteracje można przerywać jeśli odnaleziona wartość $f(c)< tol$, gdzie $tol$ jest zadaną przez nas wartością.\n
\n\nMetoda bisekcji jest wolno zbieżna (zbieżność jest liniowa), gdyż w ogóle nie korzysta z informacji jakie daje kształt funkcji $f(x)$. Jej niewątpliwą zaletą jest natomiast to, że jest pewna. Bisekcja sprawuje się dobrze, tam gdzie inne (szybsze) metody mają problemy. W obliczeniach numerycznych jest rzadko używana osobno. Za to często stosuje się ją do początkowego przybliżenia przedziału zawierającego miejsce zerowe funkcji, aby potem skorzystać z szybszych metod.\n \n
\nPseudo kod dla metody bisekcji:\n\n\n
Wejście: \n
\n fun ← funkcja, dla której szukamy miejsca zerowego \n a, b ← granice przedziału w którym znajduje się pierwiastek \n tol ← żądana dokładność \n i_max ← maksymalna ilość iteracji \n \n \n
Wyjście: \n
\n i → liczba iteracji \n c → znalezione przybliżenie pierwiastka \n fc → wartość funkcji w punkcie c \n \n \n
Algorytm: \n
\n fa ← fun(a) \n fb ← fun(b) \n if sign(fa) == sign(fb) then return error end if \n for i ← 1 to i_max do \n c ← (a + b) / 2 \n fc ← fun(c) \n e ← (b - a) / 2 if |fc| < dok then \n return i, c fc \n end if \n if sign(fc) != sign(fa) then \n b ← c \n fb ← fc \n else \n a ← c \n fa ← fc \n end if \n \n
end for \n\n
\nUzupełnij kod funkcji implementującej metodę bisekcji. Znajduje się on w poniższej komórce. \n\nJej wywołanie wygląda następująco:\n```python\n[c, yc, df] = bisect(fun, a, b, i_max, dok)\n```\n\ngdzie jej parametry to:\n\n* fun ← funkcja, dla której szukamy miejsca zerowego\n* a, b ← granice przedziału w którym znajduje się pierwiastek \n* dok ← żądana dokładność \n* i_max ← maksymalna ilość iteracji \n \na zwracane wartości to:\n\n* c → znalezione przybliżenie pierwiastka \n* yc → wartość funkcji dla znalezionego przybliżenia pierwiastka \n* df → obiekt DataFrame z danymi z każdej iteracji\n
\n\n\n\n```python\ndef bisect(fun, a, b, i_max, dok):\n \"\"\"\n :param fun: funkcja\n :param a: początek przedziału\n :param b: koniec przedziału\n :param i_max: maksymalna liczba iteracji\n :param dok: dokładność\n :return: (przybliżona wartość pierwiastka, wartość funkcji od przybliżenia, tablica z danymi z każdej iteracji)\n \"\"\"\n \n if i_max < 1:\n raise ValueError(\"i_max musi być większe od 0\")\n\n # Wartości funkcji na krańcach zadanego przedziału\n ya = fun(a)\n yb = fun(b)\n\n # Sprawdzenie czy podano poprawne wartości krańcowe\n if ya * yb > 0:\n raise ValueError(\"Wartości funkcji nie posiadają różnych znaków na początku i końcu przedziału\")\n\n \n df = pd.DataFrame(columns=[\"Krok\", \"a\", \"b\", \"c\", \"yc\", \"błąd\"])\n \n for i in range(i_max):\n # TODO\n # c = ...\n yc = fun(c)\n err = (b - a) / 2\n\n df = df.append(pd.Series(data={\"Krok\": i + 1, \"a\": a, \"b\": b, \"c\": c, \"yc\": yc, \"błąd\": err}), \n ignore_index=True)\n\n # Sprawdzenie zbieżności\n if abs(yc) < dok:\n print(f\"Metoda bisekcji zbieżna po {i + 1} iteracjach\")\n break\n\n if sign(ya) == sign(yc):\n a = c\n ya = yc\n else:\n b = c\n yb = yc\n\n\n else:\n #\n print(\"Funkcja nie mogła znaleźć przybliżenia z zadaną dokładnością w podanej liczbie iteracji\")\n \n df = df.astype({\"Krok\": \"int64\"})\n df = df.set_index(\"Krok\")\n \n return c, yc, df\n\na, b , c = bisect(lambda x: x*x + x -3, 3, 1, 100, 0.1)\nc\n```\n\n Metoda bisekcji zbieżna po 5 iteracjach\n\n\n\n\n\n\n\n
\n \n \n a \n b \n c \n yc \n błąd \n \n \n Krok \n \n \n \n \n 1 \n 3.00 \n 1.00 \n 2.00 \n 3.00 \n -1.00 \n \n \n 2 \n 2.00 \n 1.00 \n 1.50 \n 0.75 \n -0.50 \n \n \n 3 \n 1.50 \n 1.00 \n 1.25 \n -0.19 \n -0.25 \n \n \n 4 \n 1.50 \n 1.25 \n 1.38 \n 0.27 \n -0.12 \n \n \n 5 \n 1.38 \n 1.25 \n 1.31 \n 0.04 \n -0.06 \n \n \n
\n
\nPierwszym sposobem na to, aby wykorzystać informacje o kształcie funkcji do przyspieszenia zbieżności poszukiwania zera jest aproksymacja funkcji $f(x)$ za pomocą linii prostej. W metodzie regula falsi, podobnie jak metodzie połowienia zaczynamy od przedziału $[a,b]$, na którym spełniony jest warunek $f(a)f(b)<0$. Przybliżoną wartością pierwiastka w każdym następnym kroku będzie miejsce przecięcia osi OX i linii przechodzącej przez punkty $(a,f(a))$ i $(b,f(b))$, tzn:\n
\n\n\\begin{equation}\nc = b - \\frac{b-a}{f(b)-f(a)}f(b)\n \\tag{3}\n\\end{equation}\n\nJeśli zero znajduje się w przedziale $[a,c]$ zmienną $a$ pozostawiamy bez zmian i podstawiamy $b = c$; w przeciwnym przypadku przypisujemy $a=c$, z kolei $b$ pozostaje takie samo.\n
\n\nPseudo kod dla metody regula falsi:\n\n\n
Wejście: \n
\n fun ← funkcja, dla której szukamy miejsca zerowego \n a, b ← granice przedziału w którym znajduje się pierwiastek \n dok ← żądana dokładność \n i_max ← maksymalna ilość iteracji \n \n \n
Wyjście: \n
\n i → liczba iteracji \n c → znalezione przybliżenie pierwiastka \n fc → wartość funkcji w punkcie c \n \n \n
Algorytm: \n
\n fa ← fun(a) \n fb ← fun(b) \n if sign(fa) == sign(fb) then return error end if \n for i ← 1 to i_max do \n c ← b - (b - a) / (fb - fa) * fb \n fc ← fun(c) \n if |fc| < dok then \n return i, c fc \n end if \n if sign(fc) != sign(fa) then \n b ← c \n fb ← fc \n else \n a ← c \n fa ← fc \n end if \n \n
end for \n\n
\n\n
\n \n \n a \n b \n c \n yc \n \n \n Krok \n \n \n \n \n 1 \n -6.0 \n 1.000000 \n 0.250000 \n -4.687500 \n \n \n 2 \n -6.0 \n 0.250000 \n -0.736842 \n -5.193906 \n \n \n 3 \n -6.0 \n -0.736842 \n -1.642202 \n -3.945375 \n \n \n 4 \n -6.0 \n -1.642202 \n -2.236188 \n -2.235652 \n \n \n 5 \n -6.0 \n -2.236188 \n -2.545142 \n -1.067393 \n \n \n 6 \n -6.0 \n -2.545142 \n -2.686610 \n -0.468737 \n \n \n 7 \n -6.0 \n -2.686610 \n -2.747591 \n -0.198335 \n \n \n 8 \n -6.0 \n -2.747591 \n -2.773190 \n -0.082605 \n \n \n
\n
\nPodobnie jak w metodzie regula falsi, tak i w tej funkcja $f(x)$ jest aproksymowana linią prostą. Jednak metoda siecznych nie wymaga, aby w każdej iteracji sprawdzać przedział, w którym znajduje się pierwiastek. Aby rozpocząć algorytm wymagane są dwa przybliżenia pierwiastka ($x_0,x_{1}$) i nie musi być spełniony warunek $f(x_0)f(x_{1})<0$. Kolejne aproksymowane wartości pierwiastka znajdujemy (podobnie jak w powyższej metodzie) jako miejsce przecięcia się osi OX i linii przechodzącej przez dwie ostatnie aproksymacje pierwiastka $(x_{k-1},f(x_{k-1}))$ i $(x_{k},f(x_{k}))$.\n
\n \nPseudo kod dla metody siecznych: \n\n
\n\n
Wejście: \n
\n fun ← funkcja, dla której szukamy miejsca zerowego \n xn0, xn1 ← dwa pierwsze przybliżenia pierwiastka \n dok ← żądana dokładność \n i_max ← maksymalna ilość iteracji \n \n \n
Wyjście: \n
\n i → liczba iteracji \n xn2 → znalezione przybliżenie pierwiastka \n fn2 → wartość funkcji w punkcie xn2 \n \n \n
Algorytm: \n
\n for i ← 1 to i_max do \n fn0 ← fun(xn0) \n fn1 ← fun(xn1) \n xn2 ← xn1 - (xn1 - xn0) / (fn1 - fn0) * fn1 \n fn2 ← fun(xn2) \n xn0 ← xn1 \n xn1 ← xn2 \n if |fn2| < dok then \n return i, xn2, fn2 \n end if \n \n end for \n \n
\n\n\n## Ćwiczenie 4
\n\nUzupełnij kod funkcji implementującej metodę siecznych.\n\n\n```python\ndef secant(fun, xn0, xn1, i_max, dok):\n \"\"\"\n :param fun: funkcja\n :param xn0: pierwsze przybliżenie pierwiastka\n :param xn1: drugie przybliżenie pierwiastka\n :param i_max: maksymalna liczba iteracji\n :param dok: dokładność\n :return: (przybliżona wartość pierwiastka, wartość funkcji od przybliżenia, tablica z danymi z każdej iteracji)\n \"\"\"\n \n if i_max < 1:\n raise ValueError(\"i_max musi być większe od 0\")\n\n df = pd.DataFrame(columns=[\"Krok\", \"x_n\", \"x_n+1\", \"x_n+2\", \"f(x_n+2)\"])\n \n for i in range(i_max):\n \n # Wartości funkcji w dwóch pierwszych przybliżeniach\n yn0 = fun(xn0)\n yn1 = fun(xn1)\n \n # TODO\n # xn2 = ...\n \n yn2 = fun(xn2)\n\n df = df.append(pd.Series(data={\"Krok\": i + 1, \"x_n\": xn0, \"x_n+1\": xn1, \"x_n+2\": xn2, \"f(x_n+2)\": yn2}), \n ignore_index=True)\n \n # Sprawdzenie zbieżności\n if abs(yn2) < dok:\n print(f\"Metoda siecznych zbieżna po {i + 1} krokach\")\n break\n\n xn0, xn1 = xn1, xn2\n\n else:\n print(\"Funkcja nie mogła znaleźć przybliżenia z zadaną dokładnością w podanej liczbie iteracji\")\n\n df = df.astype({\"Krok\": \"int64\"})\n df = df.set_index(\"Krok\")\n \n \n return xn2, yn2, df\n\na, b, c = secant(lambda x: x*x + x - 5, -6, 1, 100, 0.01)\nc\nprint(c.to_latex())\n```\n\n Metoda siecznych zbieżna po 5 krokach\n \\begin{tabular}{lrrrr}\n \\toprule\n {} & x\\_n & x\\_n+1 & x\\_n+2 & f(x\\_n+2) \\\\\n Krok & & & & \\\\\n \\midrule\n 1 & -6.000000 & 1.000000 & 0.250000 & -4.687500 \\\\\n 2 & 1.000000 & 0.250000 & 2.333333 & 2.777778 \\\\\n 3 & 0.250000 & 2.333333 & 1.558140 & -1.014062 \\\\\n 4 & 2.333333 & 1.558140 & 1.765452 & -0.117729 \\\\\n 5 & 1.558140 & 1.765452 & 1.792681 & 0.006386 \\\\\n \\bottomrule\n \\end{tabular}\n \n\n\n## Metoda Newtona
\n
\nW metodzie Newtona jako aproksymację funkcji $f(x)$ przyjmujemy styczną do funkcji w $x_k$-tym miejscu. Następnym przybliżenie miejsca zerowego jest przecięcie stycznej z osią OX. Minusem takiego podejścia jest to, że dodatkowo jest wymagana znajomość pochodnej zadanej funkcji. Metoda ta również nie gwarantuje zbieżności procesu. Jest ona jednak najszybszą z podstawowych metod i stąd często sięga się po nią jako pierwszą. Aby obliczyć\n$k+1$-sze przybliżenie pierwiastka funkcji $f(x)$ należy zastosować wzór:\n
\n
\n\\begin{equation}\nx_{k+1} = x_k - \\frac{f(x_{k})}{f'(x_k)}\n \\tag{5}\n\\end{equation}\n \nPseudo kod dla metody Newtona: \n\n
\n\n
Wejście: \n
\n fun ← funkcja, dla której szukamy miejsca zerowego \n dfun ← pochodna funkcji fun \n xn0 ← pierwsze przybliżenia pierwiastka \n tol ← żądana dokładność \n i_max ← maksymalna ilość iteracji \n \n \n
Wyjście: \n
\n i → liczba iteracji \n xn1 → znalezione przybliżenie pierwiastka \n fn1 → wartość funkcji w punkcie xn1 \n \n \n
Algorytm: \n
\n for i ← 1 to i_max do \n xn1 ← xn0 - fun(xn0) / dfun(xn0) \n fn1 ← fun(xn1) \n if |fn1| < dok then \n return i, xn2, fn2 \n end if \n xn0 ← xn1 \n \n end for \n \n
\n\n\n## Ćwiczenie 5
\n\nUzupełnij kod funkcji implementującej metodę Newtona.\n\n\n```python\ndef newton(fun, dfun, xn0, i_max, dok):\n \"\"\"\n :param fun: funkcja\n :param dfun: pochodna funkcji f\n :param xn0: przybliżenie pierwiastka\n :param i_max: maksymalna liczba iteracji\n :param dok: dokładność\n :return: (przybliżona wartość pierwiastka, wartość funkcji od przybliżenia, tablica z danymi z każdej iteracji)\n \"\"\"\n \n if i_max < 1:\n raise ValueError(\"i_max musi być większe od 0\")\n\n df = pd.DataFrame(columns=[\"Krok\", \"x_n\", \"x_n+1\", \"f(x_n+1)\"])\n \n for i in range(i_max):\n \n # TODO\n # xn1 = ...\n yn1 = fun(xn1)\n\n df = df.append(pd.Series(data={\"Krok\": i + 1, \"x_n\": xn0, \"x_n+1\": xn1, \"f(x_n+1)\": yn1}), \n ignore_index=True)\n\n if abs(yn1) < dok:\n print(f\"Metoda Newtona zbieżna po {i + 1} krokach\")\n break\n\n xn0 = xn1\n else:\n print(\"Funkcja nie mogła znaleźć przybliżenia z zadaną dokładnością w podanej liczbie iteracji\")\n\n df = df.astype({\"Krok\": \"int64\"})\n df = df.set_index(\"Krok\")\n \n return xn1, yn1, df\n```\n\n## Metoda Newtona dla układów równań nieliniowych
\n
\nMetoda Newtona dla układów równań nieliniowych jest uogólnieniem tej metody dla pojedyńczych równań. Jej algorytm jest identyczny, wymaga tylko rozszerzenia bazowego równania tak aby pasował dla macierzy równań. W ten sposób dla układu n równań, funkcja przyjmuje wektor n pierwszych przybliżeń pierwiastków, w miejsce pojedyńczego równania przyjmuje układ równań, a zamiast pochodnej funkcji - macierz pochodnych cząstkowych układu równań, czyli tzw. jakobian. Przytaczając wzór 5 z metody Newtona \n
\n
\n\\begin{equation}\nx_{k+1} = x_k - \\frac{f(x_{k})}{f'(x_k)}\n\\end{equation}\n
\ndla układu równań można przekształcić go do postaci\n
\n\\begin{equation}\nX_{k+1} - X_{k} = - Y(X_{k})^{-1} {J(X_k)}\n \\tag{6}\n\\end{equation}\n
\n
\nZakładając teraz że lewa strona równania oznacza przyrost, należy rozwiązać równanie korzystając z arytmetyki macierzy\n dX ma znak ujemny \n \nPodstawiając teraz równanie 7 do rownania 6 otrzymuje się wzór na kolejne przybliżenie wektora pierwiastków\n \n\\begin{equation}\nX_{k+1} = X_{k} - dX\n \\tag{8}\n\\end{equation}\n\nWarunkiem stopu dla algorytmu dla układów równań, może być np. norma wektora dX, którą również można wyznaczyć za pomocą biblioteki numpy.\n \n```python\nimport numpy as np\n \n\nnorm = np.linalg.norm(dX)\n``` \n
\n\n\n## Przykład 3. Wyznaczanie pochodnych cząstkowych równań
\n\nBiorąc za przykład poniższy układ równań\n\n\\begin{cases} \n f_{1} = x^{2} + y^{2} - 25 \\\\ \n f_{2} = x + y - 7\n\\end{cases}\n
\n
\nskłada się on z dwóch równań oraz dwóch niewiadomych. Mówi to o kształcie macierzy Jacobi'ego która będzie miała rozmiar 2x2. Pierwszy rząd tej macierzy będzie się składał kolejno z pochodnej względem zmiennej x, a następnie z pochodnej względem zmiennej y pierwszego równania. Drugi rząd podobnie, tylko pod uwagę brane jest drugie równanie. \n
\n
\n\\begin{bmatrix}\n{\\frac{\\partial f_{1}}{\\partial x}} & {\\frac{\\partial f_{1}}{\\partial y}}\\\\\n{\\frac{\\partial f_{2}}{\\partial x}} & {\\frac{\\partial f_{2}}{\\partial y}}\n\\end{bmatrix}\n
\n
\nTraktując teraz funkcję jako wielomian, pochodna cząstkowa względem $x$, będzie sumą pochodnych wyrazów w których ta zmienna występuje. Jeśli w wyrazie występują inne zmienne pozostają one w tym wyrazie. Czyli np. dla wyrazu \n$x^{2}y$ pochodna cząstkowa względem $x$ będzie wynosić $2xy$. Tak samo postępuje się dla pozostałych zmiennych.\n
\n
\nJakobian dla układu równań wygląda następująco:\n
\n\\begin{bmatrix}\n2x & 2y \\\\\n1 & 1\n\\end{bmatrix} \n\n## Ćwiczenie 6
\n\nUzupełnij kod funkcji implementującej metodę Newtona dla układów równań.\n\n\n```python\nfrom numpy.linalg import inv, norm\n\n\ndef newton_nles(fun: np.array, jacobian: np.array, Xn0, i_max, dok):\n \"\"\"\n :param fun: układ X równań\n :param jacobian: jakobian równań\n :param Xn0: tablica pierwszych X przybliżeń\n :param i_max: maksymalna liczba iteracji\n :param dok: dokładność\n :return: (przybliżona wartość pierwiastka, wartość funkcji od przybliżenia, tablica z danymi z każdej iteracji)\n \"\"\"\n \n if i_max < 1:\n raise ValueError(\"i_max musi być większe od 0\")\n \n df = pd.DataFrame(columns=[\"Krok\", \"X_n\", \"f(X_n)\"])\n \n for i in range(int(i_max)):\n J = jacobian(*Xn0) \n Y = fun(*Xn0) \n # TODO\n # dX = ...\n Xn1 = Xn0 - dX\n row = pd.Series(data={\"Krok\": i + 1, \"X_n\": Xn1, \"f(X_n)\": Y})\n df = df.append(row, ignore_index=True)\n\n if np.linalg.norm(dX) < dok:\n print(f'Metoda Newtona dla układu równań nieliniowych zbieżna po {i + 1} krokach')\n break\n \n Xn0 = Xn1\n \n df = df.astype({\"Krok\": \"uint32\"})\n df = df.set_index(\"Krok\")\n \n return Xn1, df\n```\n\n## Ćwiczenie 7
\n\nPorównaj zbieżność poszczególnych metod szukając miejsca zerowego dla tych samych parametrów.\n\n\n```python\n\n```\n\n## Ćwiczenie 8
\n\nSkorzystaj z funkcji omówionej w [przykładzie 1](#rrn), aby obliczyć pierwiastki równania \n\n\\begin{equation}\nx^3+x^2-3x-3=0\n\\tag{9}\n\\end{equation}\n\n\n```python\n\n```\n\n## Ćwiczenie 9
\n
\nZaproponuj takie dane wejściowe dla metody stycznych/siecznych, aby dla funkcji posiadającej miejsce zerowe w pobliżu pierwszych/-ego przybliżenia/- żeń metoda nie była zbieżna. Jakie cechy funkcji spowodowały rozbieżność?\n Zadanie to można wykonać modyfikując przybliżenie początkowe dla funkcji fun1 lub definiując inną/ne funkcję/-je.\n
\n\n\n```python\n\n```\n\n## Ćwiczenie 10
\n\nRównanie z [ćwiczenia 8](#cw8) można przekształcić do postaci, która umożliwia wykorzystanie metody iteracji prostej $x=\\Phi(x)$ na kilka sposobów, m.in.:\n\n\n$x = \\frac{x^3+x^2-3}{3}$; $x = \\sqrt{-x^3+3x+3}$; \n\n\n$x = \\frac{-x^3+3}{x-3}$; $x = (-x^2+3x+3)^{\\frac{1}{3}}$\n\nZbadaj zbieżność metody iteracji prostej dla tych wzorów przyjmując różne przybliżenia początkowe pierwiastka, np: $x_0 = 1$ lub $x_0 = 0.1$.\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9c841a17340516f48347d78b33c9f51c9dd2642b", "size": 65377, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lab2_rownania_nieliniowe.ipynb", "max_stars_repo_name": "szaramewa/Instrukcja_rownania_nieliniowe", "max_stars_repo_head_hexsha": "4cafe7341ead82ebc5574a64a3edf9d8d56c4bf7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lab2_rownania_nieliniowe.ipynb", "max_issues_repo_name": "szaramewa/Instrukcja_rownania_nieliniowe", "max_issues_repo_head_hexsha": "4cafe7341ead82ebc5574a64a3edf9d8d56c4bf7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lab2_rownania_nieliniowe.ipynb", "max_forks_repo_name": "szaramewa/Instrukcja_rownania_nieliniowe", "max_forks_repo_head_hexsha": "4cafe7341ead82ebc5574a64a3edf9d8d56c4bf7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.9325197416, "max_line_length": 12988, "alphanum_fraction": 0.599660431, "converted": true, "num_tokens": 13635, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.39606815201671963, "lm_q2_score": 0.30735801052067535, "lm_q1q2_score": 0.12173471923445936}}
{"text": "```\n%pylab inline\nfigsize( 12.5, 4)\n```\n\n \n Welcome to pylab, a matplotlib-based Python environment [backend: module://IPython.zmq.pylab.backend_inline].\n For more information, type 'help(pylab)'.\n\n\n c:\\Python27\\lib\\site-packages\\matplotlib\\__init__.py:794: UserWarning: Bad val \"348ABD, A60628, 7A68A6, 467821, CF4457, 188487, E24A33\" on line #79\n \t\"patch.facecolor : 348ABD, A60628, 7A68A6, 467821, CF4457, 188487, E24A33\n \"\n \tin file \"c:\\Python27\\lib\\site-packages\\matplotlib\\mpl-data\\matplotlibrc\"\n \t348ABD, A60628, 7A68A6, 467821, CF4457, 188487, E24A33 does not look like a color arg\n Color tuples must be length 3\n \"%s\"\\n\\t%s' % (val, cnt, line, fname, msg))\n\n\n#Chapter 6\n\nThis chapter focuses on the most discussed part of Bayesian methodologies: how to choose a prior distribution. We also present a very interesting connection between priors and linear regression.\n\n## Getting our priorities straight\n\n\nUp until now, we have been mostly ignored our priors. This is unfortunate as we can be very expressive with our priors, but we also must be careful about choosing them. \n\n###Subjective vs Objective priors\n\nBayesian priors can be classified into two classes: *objective* priors, which aim to allow the data to speak the most, and *subjective* priors, which allow the practioner to express his or her views into the prior. \n\nWhat is an example of a objective prior? We have seen a some already, including the *flat* prior (which is a uniform distribution over the entire range of the unknown). This implies we give each possible value an equal chance. Choosing this type of prior is invoking what is called \"The Principle of Indifference.\"\n\nConversely, if we added more probability to certain areas of the prior, and less elsewhere, we are biasing our results towards the former area. This is an subjective, or *informative* prior. A subjective prior does not always reflect the practioner's opinion: more often the subjective prior was once a posterior to a previous problem, and know the practioner is updating this posterior with new data.\n\n\n```\nimport scipy.stats as stats\nfigsize(12.5,2.5)\nx = np.linspace(0,1)\n\ny1, y2 = stats.beta.pdf(x, 1,1), stats.beta.pdf(x, 10,10)\n\nplt.plot( x, y1, \n label='Objective \\n( uninformative, \\n\"Principle of Indifference\" )' )\nplt.plot( x,y2 ,\n label = \"Subjective \\n( informative)\" )\n\nleg = plt.legend()\nleg.get_frame().set_alpha(0.4)\nplt.title(\"Comparing objective vs. subjective priors\" );\n```\n\nThe choice, either *objective* or *subjective* mostly depend on the problem being solved, but there are a few cases where one is preferred over the other. In instances of scientific research, the choice of an objective prior is obvious. This eliminiates any biases in the results, and two researchers who might have differing prior opionions would feel an objective prior is fair. Consider an more extreme situation:\n\n> A tobacco company publishes an report with a Bayesian methodology that retreated 60 years of medical research on tobacco use, would you believe them? No, probably because they choose a subjective prior that too strongly biased results in there favour.\n\nUnfortunately, choosing a objective prior is not obvious, and the topic even today the problem is still not completely solved. Gelmen *et al.* [3] suggest that using a uniform distribution, with a large margin, is probably the best.\n\nWe must remember that choosing a prior, whether subjective or objective, is still part of the modelling process. To quote Gelman [3]\n\n>...after the model has been fit, one should look at the posterior distribution\nand see if it makes sense. If the posterior distribution does not make sense, this implies\nthat additional prior knowledge is available that has not been included in the model,\nand that contradicts the assumptions of the prior distribution that has been used. It is\nthen appropriate to go back and alter the prior distribution to be more consistent with\nthis external knowledge.\n\nIf the posterior does not make sense, then clearly one had an idea what the posterior *should* look like (not what one *hopes* it looks like), implying that the current prior does not contain all the prior information and should be updated. At this point, we can discard the objective prior and choose a more reflective one.\n\nAlthough, one should be wary about using Uniform objective priors with large margins. Do you really think the unknown could be incredibly large? Often quantities are naturally biased towards 0. A Normal random variable with large variance (small precision) is often a better choice. \n\nEither way, if using a subjective prior, **it is important to explain the rationale**, else you are no better than the tobacoo company's guilty parties. \n\nWe next introduce the Beta distribution.\n\n### The Beta distribution\n\nYou may have seen the term `beta` in previous code in this book. Often, I was implementing a Beta distribution. The Beta distribution is very useful in Bayesian statistics. A random variable $X$ has a $\\text{Beta}$ distribution, with paramters $(\\alpha, \\beta)$, if its density function is:\n\n$$f_X(x | \\; \\alpha, \\beta ) = \\frac{ x^{(\\alpha - 1)}(1-x)^{ (\\beta - 1) } }{B(\\alpha, \\beta) }$$\n\nwhere $B$ is the [Beta function](http://en.wikipedia.org/wiki/Beta_function) (hence the name). The random variable $X$ is only allowed in [0,1], making the Beta distribution a popular distribution for decimal values, probabilities and proportions. The values of $\\alpha$ and $\\beta$, both positive values, provide great flexibility in the shape of the distribution. Below we plot some distributions:\n\n\n```\nfigsize( 12.5, 5 )\nimport scipy.stats as stats\n\nparams = [ (1,1), (2,5), (0.5, 0.5), ( 5, 5), (20, 4), (5, 1) ]\ncolors = [\"#348ABD\", \"#A60628\", \"#7A68A6\", \"#467821\", \n \"#CF4457\", \"#188487\", \"#E24A33\" ]\nx = np.linspace( 0, 1, 100 )\nbeta = stats.beta\nfor c, (a, b) in zip(colors,params):\n y = beta.pdf( x, a, b )\n plt.plot( x, y, label = \"(%.1f,%.1f)\"%(a,b) )\n plt.fill_between( x, 0, y, alpha = 0.2, color = c )\n\nplt.ylim(0)\nplt.legend(loc = 'upper left');\n```\n\nOne thing I'd like the reader to notice is the flat distribution above, specified by parameters $(1,1)$. This is the Uniform distribution. Hence the Beta distribution is a generalization of the Uniform distribution, something we will revisit many times.\n\nThere is an interesting connection beween the Beta distribution and the Binomial distribution. Suppose we are interested in some unknown proportion or probability $p$. We assign a $\\text{Beta}(\\alpha, \\beta)$ prior to $p$. We observe some data genereted by a Binomial process, say $X \\sim \\text{Binomial}(N, p)$. Then our posterior *is a Beta disitribution*, i.e. $p | X \\sim \\text{Beta}( \\alpha + X, \\beta + N -X )$. Succinctly, one can relate the two by \"a Beta prior with Binomial observations creates a Beta posterior\". This is a very useful property, both computationally and heuristically.\n\nIn light of the above two paragraphs, if we start with a $\\text{Beta}(1,1)$ prior on $p$ (which is a Uniform), observe data $X \\sim \\text{Binomial}(N, p)$, then our posterior is $\\text{Beta}(1 + X, 1 + N - X)$. \n\n\n#####Example: Bayesian Multi-Armed Bandits\n*Adapted from an example by Ted Dunning of MapR Technologies*\n\n> Suppose you are faced with $N$ slot machines (colourfully called multi-armed bandits). Each bandit has an unknown probability of distributing a prize (assume for now the prizes are the same for each bandit, only the probabilities differ). Some bandits are very generous, others not so much. Of course, you don't know what these probabilities are. By only choosing one bandit per round, our task is devise a strategy to maximize our winnings.\n\nOf course, if we knew the bandit with the largest probability, then always picking this bandit would yield the maximum winnings. So our task can be phrased as \"Find the best bandit, and as quickly as possible\". \n\nThe task is complicated by the stochastic nature of the bandits. A suboptimal bandit can return many winnings, purely by chance, which would make us believe that it is a very profitable bandit. Similarly, the best bandit can return many duds. Should we keep trying losers then, or give up? \n\nA more troublesome problem is, if we have a found a bandit that returns *pretty good* results, do we keep drawing from it to maintain our *pretty good score*, or do we try other bandits in hopes of finding an *even-better* bandit? This is the exploration vs. exploitation dilemma.\n\n### Applications\n\n\nThe Multi-Armed Bandit problem at first seems very artificial, something only a mathematician would love, but that is only before we address some applications:\n\n1. Internet display advertising: companies have a suite of potential ads they can display to visitors, but the company is not sure which ad strategy to follow to maximize sales. This is similar to A/B testing, but has the added advantage of naturally minimizing strategies that do not work (and generalizes to A/B/C/D... strategies)\n2. Ecology: animals have a finite amount of energy to expend, and following certain behaviours has uncertain rewards. How does the animal maximize its fitness?\n3. Finance: which stock option gives the highest return, under time-varying return profiles.\n4. Clinical trials: a researcher would like to find the best treatment, out of many possible treatment, while minimizing losses. \n5. Psychology: how does punishment and reward effect our behaviour? How do humans' learn?\n\nMany of these questions above a fundamental to the application's field.\n\nIt turns out the *optimal solution* is incredibly difficult, and it took decades for an overall solution to develop. There are also many approximately-optimal solutions which are quite good. The one I wish to discuss is one of the few solutions that can scale incredibly well. The solution is known as *Bayesian Bandits*.\n\n\n### A Proposed Solution\n\n\nAny proposed strategy is called an *online algorithm* (not in the internet sense, but in the continuously-being-updated sense), and more specifically a reinforcement learning algorithm. The algorithm starts in an ignorant state, where it knows nothing, and begins to acquire data by testing the system. As it acquires data and results, it learns what the best and worst behaviours are (in this case, it learns which bandit is the best). With this in mind, perhaps we can add an additional application of the Multi-Armed Bandit problem:\n\n- Psychology: how does punishment and reward effect our behaviour? How do humans' learn?\n\n\nThe Bayesian solution begins by assuming priors on the probability of winning for each bandit. In our vignette we assumed complete ignorance of the these probabilities. So a very natural prior is the flat prior over 0 to 1. The algorithm proceeds as follows:\n\nFor each round:\n\n1. Sample a random variable $X_b$ from the prior of bandit $b$, for all $b$.\n2. Select the bandit with largest sample, i.e. select $B = \\text{argmax}\\;\\; X_b$.\n3. Observe the result of pulling bandit $B$, and update your prior on bandit $B$.\n4. Return to 1.\n\nThat's it. Computationally, the algorithm involves sampling from $N$ distributions. Since the initial priors are $\\text{Beta}(\\alpha=1,\\beta=1)$ (a uniform distribution), and the observed result $X$ (a win or loss, encoded 1 and 0 respectfully) is Binomial, the posterior is a $\\text{Beta}(\\alpha=1+X,\\beta=1+1−X)$.\n\nTo answer our question from before, this algorithm suggests that we should not discard losers, but we should pick them at a decreasing rate as we gather confidence that there exist *better* bandits. This follows because there is always a non-zero chance that a loser will achieve the status of $B$, but the probability of this event decreases as we play more rounds (see figure below).\n\nBelow we implement Bayesian Bandits using two classes, `Bandits` that defines the slot machines, and `BayesianStrategy` which implements the above learning strategy.\n\n\n```\nfrom pymc import rbeta\n\nrand = np.random.rand\n\nclass Bandits(object):\n \"\"\"\n This class represents N bandits machines.\n\n parameters:\n p_array: a (n,) Numpy array of probabilities >0, <1.\n\n methods:\n pull( i ): return the results, 0 or 1, of pulling \n the ith bandit.\n \"\"\"\n def __init__(self, p_array):\n self.p = p_array\n self.optimal = np.argmax(p_array)\n \n def pull( self, i ):\n #i is which arm to pull\n return rand() < self.p[i]\n \n def __len__(self):\n return len(self.p)\n\n \nclass BayesianStrategy( object ):\n \"\"\"\n Implements a online, learning strategy to solve\n the Multi-Armed Bandit problem.\n \n parameters:\n bandits: a Bandit class with .pull method\n \n methods:\n sample_bandits(n): sample and train on n pulls.\n\n attributes:\n N: the cumulative number of samples\n choices: the historical choices as a (N,) array\n bb_score: the historical score as a (N,) array\n\n \"\"\"\n \n def __init__(self, bandits):\n \n self.bandits = bandits\n n_bandits = len( self.bandits )\n self.wins = np.zeros( n_bandits )\n self.trials = np.zeros(n_bandits )\n self.N = 0\n self.choices = []\n self.bb_score = []\n\n \n def sample_bandits( self, n=1 ):\n \n bb_score = np.zeros( n )\n choices = np.zeros( n )\n \n for k in range(n):\n #sample from the bandits's priors, and select the largest sample\n choice = np.argmax( rbeta( 1 + self.wins, 1 + self.trials - self.wins) )\n \n #sample the chosen bandit\n result = self.bandits.pull( choice )\n \n #update priors and score\n self.wins[ choice ] += result\n self.trials[ choice ] += 1\n bb_score[ k ] = result \n self.N += 1\n choices[ k ] = choice\n \n self.bb_score = np.r_[ self.bb_score, bb_score ]\n self.choices = np.r_[ self.choices, choices ]\n return \n```\n\nBelow we visualize the learning of the Bayesian Bandit solution.\n\n\n```\nimport scipy.stats as stats\nfigsize( 11.0, 10)\n\nbeta = stats.beta\nx = np.linspace(0,1,200)\n\ndef plot_priors(bayesian_strategy, prob):\n ## plotting function\n wins = bayesian_strategy.wins\n trials = bayesian_strategy.trials\n for i in range( prob.shape[0] ):\n y = beta( 1+wins[i], 1 + trials[i] - wins[i] )\n p = plt.plot( x, y.pdf(x) )\n c = p[0].get_markeredgecolor()\n plt.fill_between(x,y.pdf(x),0, color = c, alpha = 0.3, \n label=\"underlying probability: %.2f\"%prob[i])\n plt.vlines( prob[i], 0, y.pdf(prob[i]) ,\n colors = c, linestyles = \"--\" )\n plt.title(\"Posteriors After %d pull\"%bayesian_strategy.N +\\\n \"s\"*(bayesian_strategy.N>1) )\n return\n\n\nhidden_prob = np.array([0.85, 0.60, 0.75] )\nbandits = Bandits( hidden_prob )\nbayesian_strat = BayesianStrategy( bandits )\n\nfor j,i in enumerate([1, 1, 3, 10, 10, 25, 50, 100, 200, 600 ]):\n subplot( 5, 2, j+1) \n bayesian_strat.sample_bandits(i)\n plot_priors( bayesian_strat, hidden_prob )\n #plt.legend()\n\nplt.tight_layout()\n\n```\n\nNote that we don't real care how accurate we become about inference of the hidden probabilities -- for this problem we are more interested in choosing the best bandit (or more accurately, becoming *more confident* in choosing the best bandit). For this reason, the distribution of the red bandit is very wide (representing ignorance about what that hidden probability might be) but we are reasonably confident that it is not the best, so the algorithm chooses to ignore it.\n\n\n### A Measure of *Good*\n\nWe need a metric to calculate how well we are doing. Recall the absolute *best* we can do is to always pick the bandit with the largest probability of winning. Denote this best bandit's probability of $w^*$. Our score should be relative to how well we would have done had we chosen the best bandit from the beginning. This motivates the *total regret* of a strategy, defined:\n\n\\begin{align}\nR_T & = \\sum_{i=1}^{T} \\left( w^* - w_{B(i)} \\right)\\\\\\\\\n& = Tw^* - \\sum_{i=1}^{T} \\; w_{B(i)} \n\\end{align}\n\n\nwhere $w_{B(i)}$ is the probability of a prize of the chosen bandit in the $i$ round. A total regret of 0 means the strategy is matching the best possible score. This is likely not possible, as initially our algorithm will often make the wrong choice. Ideally, a strategy's total regret should flatten as it learns the best bandit. (Mathematically we achieve $w_{B(i)}=w^*$ often)\n\n\nBelow we plot the total regret of this simulation, including the score if we randomly chose a bandit.\n\n\n```\nfigsize( 12.5, 3 )\n\ndef regret( probabilities, choices ):\n w_opt = probabilities.max()\n return ( w_opt - probabilities[choices.astype(int)] ).cumsum()\n\n\n#train 9000 more times. It's over 9000 now.\nbayesian_strat.sample_bandits(9000)\n\nbayesian_strategy_regret = regret( hidden_prob, \n bayesian_strat.choices ) \nrandom_strategy_regret = regret( hidden_prob, \n np.random.randint( 0, 3, size=10000) )\n\n#plotit\nplt.plot(bayesian_strategy_regret, label = \"Bayesian Bandit Strategy\" )\nplt.plot( random_strategy_regret, label = \"Random guessing\" )\nplt.title(\"Total Regret of Bayesian Bandits Strategy vs. Random guessing\" )\nplt.xlabel(\"Number of pulls\")\nplt.ylabel(\"Regret after $n$ pulls\");\nplt.legend(loc = \"upper left\")\n\n\nfigure()\nplt.plot(bayesian_strategy_regret, label = \"Bayesian Bandit Strategy\" )\nplt.title(\"Total Regret of Bayesian Bandits Strategy\" )\nplt.xlabel(\"Number of pulls\")\nplt.ylabel(\"Regret after $n$ pulls\");\nplt.legend(loc = \"upper left\")\n```\n\nLike we wanted, the graph starts to flatten, representing we are achieving optimal choices. To be more scientific so as to remove any possible luck in the above simulation, we should instead look at the *expected total regret*:\n\n$$\\bar{R_T} = E[ R_T ] $$\n\nIt can be shown that any *sub-optimal* strategy's expected total regret is bounded below logarithmically. Formally,\n\n$$ E[R_T] = \\Omega \\left( \\;\\log(T)\\; \\right)$$\n\nThus, any strategy that matches logarithmic-growing regret is said to \"solve\" the Multi-Armed Bandit problem [3].\n\nUsing the Law of Large Numbers, we can approximate Bayesian Bandit's expected total regret by performing the same experiment many times (25 times, to be fair):\n\n\n```\nexpected_total_regret = np.zeros(10000)\ntrials = 25\n\nfor i in range(trials):\n bayesian_strat = BayesianStrategy( bandits )\n bayesian_strat.sample_bandits(10000)\n bayesian_strategy_regret = regret( hidden_prob, \n bayesian_strat.choices ) \n expected_total_regret += bayesian_strategy_regret\n \nplot(expected_total_regret/trials )\n#plt.ylim( 0, expected_total_regret.max() )\nplt.title(\"Expected Total Regret of Bayesian Bandits Strategy\" )\nplt.xlabel(\"Number of pulls\")\nplt.ylabel(\"Exepected Total Regret after $n$ pulls\");\n\nfigure()\nplot(expected_total_regret/trials )\n#plt.ylim( 0, expected_total_regret.max() )\nplt.title(\"Expected Total Regret of Bayesian Bandits Strategy, log-scale\" )\nplt.xlabel(\"Log Number of pulls\")\nplt.ylabel(\"Exepected Total Regret \\n after $\\log{n}$ pulls\");\nplt.xscale(\"log\")\n\n```\n\n### Extending the algorithm \n\n\nBecause of the algorithm's simplicity, it is easy to extend it. Some possibilities:\n\n1. If interested in the *minimum* probability (eg: where prizes are are bad thing), simply choose $B = \\text{argmin} \\; X_b$ and proceed.\n\n2. Adding learning rates: Suppose the underlying environment may change over time. Technically the standard Bayesian Bandit algorithm would self-update itself (awesome) by noting that what it thought was the best is starting to fail more often, we can motivate the algorithm to learn changing environments quicker. We simply need to add a *rate* term upon updating:\n\n self.wins[ choice ] = rate*self.wins[ choice ] + result\n self.trials[ choice ] = rate*self.trials[ choice ] + 1\n\n If `rate < 1`, the algorithm will *forget* its previous wins quicker and there will be a downward pressure towards ignorance. Conversely, setting `rate > 1` implies your algorithm will act more risky, and bet on earlier winners more often and be more resistant to changing environments. \n\n2. Hierarchical algorithms: We can setup a Bayesian Bandit algorithm on top of smaller bandit algorithms. Suppose we have $N$ Bayesian Bandit models, each varying in some behavior (for example different `rate` parameters, representing varying sensitivity to changing environments). On top of these $N$ models is another Bayesian Bandit learner that will select a sub-Bayesian Bandit. This chosen Bayesian Bandit will then make an internal choice as to which machine to pull. The super-Bayesian Bandit updates itself depending on whether the sub-Bayesian Bandit was correct or not. \n\n \n\n\n```\nfigsize( 12.0, 12)\nbeta = stats.beta\nhidden_prob = beta.rvs(1,1, size = 10 )\nprint hidden_prob\nbandits = Bandits( hidden_prob )\nbayesian_strat = BayesianStrategy( bandits )\n\nfor j,i in enumerate([1, 1, 3, 10, 10, 25, 50, 100, 200, 600 ]):\n subplot( 5, 2, j+1) \n bayesian_strat.sample_bandits(i)\n plot_priors( bayesian_strat, hidden_prob )\n #plt.legend()\n\n\n```\n\n\n```\ndef regret( probabilities, choices ):\n w_opt = probabilities.max()\n return ( w_opt - probabilities[choices.astype(int)] ).cumsum()\n\n\n#train 9000 more times. It's over 9000 now.\n\nbayesian_strat.sample_bandits(9000)\n\nbayesian_strategy_regret = regret( hidden_prob, \n bayesian_strat.choices )\n\nfigure()\nplt.plot(bayesian_strategy_regret, label = \"Bayesian Bandit Strategy\" )\nplt.title(\"Total Regret of Bayesian Bandits Strategy\" )\nplt.xlabel(\"Number of pulls\")\nplt.ylabel(\"Regret after $n$ pulls\");\nplt.legend(loc = \"upper left\")\nplt.xscale(\"log\")\n\n\n```\n\n##Effect of the prior as $N$ increases\n\nIn the first Chapter, I proposed that as the amount of observations, or data, that we posses, the less the prior matters. This is intuitive. After all, our prior is based on previous information, and eventually enough new information will shadow our previous information's value. The smothering of the prior by enough data is also helpful: if our prior is significantly wrong, then the self-correcting nature of the data will present to us a *less wrong*, and eventually *correct*, posterior. \n\nWe can see this mathematically. First, recall Bayes Theorem from Chapter 1 that relates the prior to the posterior. The following is a sample from [What is the relationship between sample size and the influence of prior on posterior?](http://stats.stackexchange.com/questions/30387/what-is-the-relationship-between-sample-size-and-the-influence-of-prior-on-poste)[1] on CrossValidated.\n\n>The posterior distribution for a parameter $\\theta$, given a data set ${\\bf X}$ can be written as \n\n\\begin{equation}\np(\\theta | {\\bf X}) \\propto \\underbrace{p({\\bf X} | \\theta)}_{{\\rm likelihood}} \\cdot \\underbrace{ p(\\theta)}_{{\\rm prior} }\n\\end{equation}\n\n\n>or, as is more commonly displayed on the log scale, \n\n$$ \\log( p(\\theta | {\\bf X}) ) = c + L(\\theta;{\\bf X}) + \\log(p(\\theta)) $$\n\n>The log-likelihood, $L(\\theta;{\\bf X}) = \\log \\left( p({\\bf X}|\\theta) \\right)$, **scales with the sample size**, since it is a function of the data, while the prior density does not. Therefore, as the sample size increases, the absolute value of $L(\\theta;{\\bf X})$ is getting larger while $\\log(p(\\theta))$ stays fixed (for a fixed value of $\\theta$), thus the sum $L(\\theta;{\\bf X}) + \\log(p(\\theta))$ becomes more heavily influenced by $L(\\theta;{\\bf X})$ as the sample size increases. \n\nThere is an interesting consequence not immediately apparent. For large sample sizes, the choice prior has less influence. Hence inference converges regardless of chosen prior, so long as areas of the prior assign non-zero probabilities are the same. \n\nBelow we visualize this. We examine the convergence of two posteriors of a Binomial's parameter $\\theta$, one with a flat prior and the other with a biased prior towards 0. As the sample size increases, the posteriors, and hence the inference, converge.\n\n\n```\nfigsize( 12.5, 15)\nimport scipy.stats as stats\nimport pymc as mc\n\np = 0.6\nbeta1_params = np.array( [1.,1.] )\nbeta2_params = np.array( [2,10] )\nbeta = stats.beta\n\nx = np.linspace(0.00, 1, 125)\ndata = mc.rbernoulli(p, size=500)\n\nfigure()\nfor i,N in enumerate([0,4,8, 32,64, 128, 500]):\n s = data[:N].sum() \n subplot(8,1,i+1)\n params1 = beta1_params + np.array( [s, N-s] )\n params2 = beta2_params + np.array( [s, N-s] )\n y1,y2 = beta.pdf( x, *params1), beta.pdf( x, *params2)\n plt.plot( x,y1, label = r\"flat prior\", lw =3 )\n plt.plot( x, y2, label = \"biased prior\", lw= 3 )\n plt.fill_between( x, 0, y1, color =\"#348ABD\", alpha = 0.15) \n plt.fill_between( x, 0, y2, color =\"#A60628\", alpha = 0.15) \n plt.legend(title = \"N=%d\"%N)\n plt.vlines( p, 0.0, 7.5, linestyles = \"--\", linewidth=1)\n #plt.ylim( 0, 10)#\n\n```\n\nKeep in mind, not all posteriors will \"forget\" the prior this quickly. This example was just to show that *eventually* the prior is forgotten. \n\n### Bayesian perspective of Penalized Linear Regressions\n\nThere is a very interesting relationship between the penalized least-squares regression and Bayesian priors. We will first describe the probablistic interpretation of Linear Regression. Denote our response variable $Y$, and features are contained in the data matrix $X$. The standard linear model is:\n\n\\begin{equation}\nY = X\\beta + \\epsilon\n\\end{equation}\n\nwhere $\\epsilon \\sim \\text{Normal}( {\\bf 0}, \\sigma{\\bf I })$. Simpley, the observed $Y$ is a linear function of $X$ (with coeffcients $\\beta$) plus some noise term. Our unknown to be learned is $\\beta$. We use the following property of Normal random variables:\n\n$$ \\mu' + \\text{Normal}( \\mu, \\sigma ) \\sim \\text{Normal}( \\mu' + \\mu , \\sigma ) $$\n\nto rewrite the above linear model as:\n\n\\begin{align}\n& Y = X\\beta + \\text{Normal}( {\\bf 0}, {\\bf I }) \\\\\\\\\n& Y = \\text{Normal}( X\\beta , {\\bf I }) \\\\\\\\\n\\end{align}\n\nIn probabilitistic notation, denote $f_Y(y \\; | \\; \\beta )$ the probabilitiy distribution of $Y$, and recall the density function for a Normal random variable:\n\n$$ f_Y( Y \\; |\\; \\beta, X) = L(\\beta|\\; X,Y)= \\frac{1}{\\sqrt{ 2\\pi\\sigma} } \\exp \\left( \\frac{1}{2\\sigma^2} (Y - X\\beta)^T(Y - X\\beta) \\right) $$\n\nThis is the likelihood function for $\\beta$ Taking the $\\log$:\n\n$$ \\ell(\\beta) = K - c(Y - X\\beta)^T(Y - X\\beta) $$\n\nwhere $K$ and $c>0$ are constants. Maximum likelihood techniques wish to maximize this for $\\beta$, \n\n$$\\hat{ \\beta } = \\text{argmax}_{\\beta} \\;\\; - (Y - X\\beta)^T(Y - X\\beta) $$\n\nEquivilantly we can minimize the negative of the above:\n\n$$\\hat{ \\beta } = \\text{argmin}_{\\beta} \\;\\; (Y - X\\beta)^T(Y - X\\beta) $$\n\nThis is probably the familiar least-squares linear regression equation. We showed that the solution to this is the same as the maximum likelihood assuming Normal noise. Next we extend this to show how we can arrive at penalized linear regression by a suitable choice of priors on $\\beta$. \n\n#### Penalized least-squares\n\nIn the above, once we have the likelihood, we can include a prior distribution on $\\beta$ to move to the equation for the posterior distribution:\n\n$$P( \\beta | Y, X ) = L(\\beta|\\;X,Y)p( \\beta )$$\n\nwhere $p(\\beta)$ is a prior on the elements of $\\beta$. What are some interesting priors? \n\n1\\. If we include *no explicit* prior term, we are actually including an uniformative prior, $P( \\beta ) \\propto 1$. \n\n2\\. If we have reason to believe the elements of $\\beta$ are not too large, we can suppose that *apriori*:\n\n$$ \\beta \\sim \\text{Normal}({\\bf 0 }, \\lambda {\\bf I } ) $$\n\nThe resulting posterior density function for $\\beta$ is *proportional to*:\n\n$$ \\exp \\left( \\frac{1}{2\\sigma^2} (Y - X\\beta)^T(Y - X\\beta) \\right) \\exp \\left( \\frac{1}{2\\lambda^2} \\beta^T\\beta \\right) $$\n\nand taking the $\\log$ of this, and combining some constants, we get:\n\n$$ \\ell(\\beta) \\propto K - (Y - X\\beta)^T(Y - X\\beta) - \\alpha \\beta^T\\beta $$\n\nwe arrive at the function we wish to maximize (recall the point that maximizes the posterior distribution is the MAP, or *maximum a posterior*):\n\n$$\\hat{ \\beta } = \\text{argmax}_{\\beta} \\;\\; -(Y - X\\beta)^T(Y - X\\beta) - \\alpha \\;\\beta^T\\beta $$\n\nEquivilantly, we can minimize the negative of the above, and rewriting $\\beta^T\\beta = ||\\beta||_2^2:\n\n$$\\hat{ \\beta } = \\text{argmin}_{\\beta} \\;\\; (Y - X\\beta)^T(Y - X\\beta) + \\alpha \\;||\\beta||_2^2$$\n\nThis above term is exactly Ridge Regression. Thus we can see that ridge regression corresponds to the MAP of a linear model with Normal errors and a Normal prior on $\\beta$.\n\n3\\. Similarly, if we assume a *Laplace* prior on $\\beta$, ie. \n\n$$ f_\\beta( \\beta) \\propto \\exp \\left(- \\lambda ||\\beta||_1 \\right)$$\n\nand following the same steps as above, we recover:\n\n$$\\hat{ \\beta } = \\text{argmin}_{\\beta} \\;\\; (Y - X\\beta)^T(Y - X\\beta) + \\alpha \\;||\\beta||_1$$\n\nwhich is LASSO regression. Some important notes about this equilivance. The sparsity that is a result of using a LASSO regularization is not a result of the prior assigning high probability to sparsity. Quite the opposite actually. It is the combination of the $|| \\cdot ||_1$ function and using the MAP that creates sparsity on $\\beta$: purely a geometric argument. The prior does contribute to an overall shrinking of the coefficients towards 0 though. An interesing disucssion of this can be found in [2].\n\n##### References\n\n1. http://stats.stackexchange.com/questions/30387/what-is-the-relationship-between-sample-size-and-the-influence-of-prior-on-poste\n\n2. Starck, J.-L., , et al. \"Sparsity and the Bayesian Perspective.\" Astronomy & Astrophysics. (2013): n. page. Print.\n\n3. Kuleshov, Volodymyr, and Doina Precup. \"Algorithms for the multi-armed bandit problem.\" Journal of Machine Learning Research. (2000): 1-49. Print.\n\n\n```\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "733abeaa2da4c899f33368514ed6d3a4975e99ef", "size": 873543, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter6_Priorities/Priors.ipynb", "max_stars_repo_name": "elyase/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "1b587fe9652168553d25fdde7ba46a3d4e08ff0d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-06-22T16:15:11.000Z", "max_stars_repo_stars_event_max_datetime": "2018-06-22T16:15:11.000Z", "max_issues_repo_path": "Chapter6_Priorities/Priors.ipynb", "max_issues_repo_name": "elyase/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "1b587fe9652168553d25fdde7ba46a3d4e08ff0d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter6_Priorities/Priors.ipynb", "max_forks_repo_name": "elyase/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "1b587fe9652168553d25fdde7ba46a3d4e08ff0d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 996.0581527936, "max_line_length": 227604, "alphanum_fraction": 0.93455388, "converted": true, "num_tokens": 8124, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4571367168274948, "lm_q2_score": 0.2658804672827598, "lm_q1q2_score": 0.12154372388220097}}
{"text": "```python\nfrom IPython.core.display import display_html\nfrom urllib.request import urlopen\n\ncssurl = 'http://j.mp/1DnuN9M'\ndisplay_html(urlopen(cssurl).read(), raw=True)\n```\n\n\n
\n
\n\n\n\n\n\n\n# Modelado matemático y simulación de sistema carro-pendulo\n\n## Problema\n\nDado el sistema de la siguiente figura:\n\n\n\ndescribir matemáticamente su comportamiento ante perturbaciones externas.\n\n## Modelado matemático\n\nUtilizaremos el enfoque de Euler-Lagrange, el cual nos dice que el primer paso para conseguir el modelo matemático es calcular el Lagrangiano $L$ del sistema, definido por:\n\n$$\nL = K - U\n$$\n\nen donde $K$ es la energía cinética del sistema y $U$ es la energia potencial del sistema.\n\nEl estado del sistema estará descrito por una distancia $x$ del centro del carro a un marco de referencia y el angulo $\\theta$ del pendulo con respecto a la horizontal.\n\n$$\nq = \\begin{pmatrix} x \\\\ \\theta \\end{pmatrix} = \\begin{pmatrix} q_1 \\\\ q_2 \\end{pmatrix} \\implies\n\\dot{q} = \\begin{pmatrix} \\dot{x} \\\\ \\dot{\\theta} \\end{pmatrix} = \\begin{pmatrix} \\dot{q}_1 \\\\ \\dot{q}_2 \\end{pmatrix} \\implies\n\\ddot{q} = \\begin{pmatrix} \\ddot{x} \\\\ \\ddot{\\theta} \\end{pmatrix} = \\begin{pmatrix} \\ddot{q}_1 \\\\ \\ddot{q}_2 \\end{pmatrix}\n$$\n\nPara calcular la energía cinética del sistema, obtenemos $K_1$ y $K_2$ asociadas al carro y al pendulo, en donde $K_i = \\frac{1}{2} m_i v_i^2$, por lo que tenemos:\n\n$$\nK_1 = \\frac{1}{2} m_1 v_1^2 = \\frac{1}{2} m_1 \\dot{x}^2 = \\frac{1}{2} m_1 \\dot{q}_1^2\n$$\n\n$$\nK_2 = \\frac{1}{2} m_2 v_2^2 = \\frac{1}{2} m_2 \\left[ \\left( \\dot{x} + \\dot{x}_2 \\right)^2 + \\dot{y}_2^2 \\right]\n$$\n\ncon $x_2 = l \\cos{\\theta}$ y $y_2 = l \\sin{\\theta}$, por lo que sus derivadas son $\\dot{x}_2 = -\\dot{\\theta} l \\sin{\\theta}$ y $\\dot{y}_2 = \\dot{\\theta} l \\cos{\\theta}$, por lo que $K_2$ queda:\n\n$$\n\\begin{align}\nK_2 &= \\frac{1}{2} m_2 \\left[ \\left( \\dot{x} -\\dot{\\theta} l \\sin{\\theta} \\right)^2 + \\left( \\dot{\\theta} l \\cos{\\theta} \\right)^2 \\right] \\\\\n&= \\frac{1}{2} m_2 \\left[ \\left( \\dot{x} -\\dot{\\theta} l \\sin{\\theta} \\right)^2 + \\left( \\dot{\\theta} l \\cos{\\theta} \\right)^2 \\right] \\\\\n&= \\frac{1}{2} m_2 \\left[ \\left( \\dot{q}_1 -\\dot{q}_2 l \\sin{q_2} \\right)^2 + \\left( \\dot{q}_2 l \\cos{q_2} \\right)^2 \\right]\n\\end{align}\n$$\n\nConfirmemos estos calculos:\n\n\n```python\nfrom IPython.display import display\n\nfrom sympy import var, simplify, collect, expand, solve, sqrt, sin, cos, Matrix, Integer, diff, Function, Rational\nfrom sympy.physics.mechanics import mlatex, mechanics_printing\nmechanics_printing()\n```\n\n\n```python\nvar(\"l t m1 m2 g\")\n```\n\n\n```python\nq1 = Function(\"q_1\")(t)\nq2 = Function(\"q_2\")(t)\n\nx = Function(\"x\")(t)\n```\n\n\n```python\nx1 = q1\ny1 = Integer(0)\nv1 = sqrt(x1.diff(t)**2 + y1.diff(t)**2)\nv1, v1**2\n```\n\n\n```python\nx2 = q1 + l*cos(q2)\ny2 = l*sin(q2)\nv2 = sqrt(x2.diff(t)**2 + y2.diff(t)**2)\nv2, v2**2\n```\n\n\n```python\nk1 = Rational(1, 2)*m1*v1**2\nk2 = Rational(1, 2)*m2*v2**2\nk1, k2\n```\n\n\n```python\nK = (k1 + k2).expand().trigsimp().factor(q1.diff(t), q2.diff(t))\nK\n```\n\nEntonces la energía cinética será:\n\n$$\nK = \\frac{1}{2} \\left[ (m_1 + m_2) \\dot{q}_1^2 + m_2 l^2 \\dot{q}_2^2 - 2 m_2 l \\sin{q_2} \\dot{q}_1 \\dot{q}_2 \\right]\n$$\n\nLo cual puede ser escrito como una forma matricial cuadratica:\n\n$$\nK = \\frac{1}{2}\n\\begin{pmatrix}\n\\dot{q}_1 & \\dot{q}_2\n\\end{pmatrix}\n\\begin{pmatrix}\nm_1 + m_2 & -m_2 l \\sin{q_2} \\\\\n-m_2 l \\sin{q_2} & m_2 l^2\n\\end{pmatrix}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix}\n$$\n\n\n```python\nM = Matrix([[m1 + m2, -m2*l*sin(q2)],\n [-m2*l*sin(q2), m2*l**2]])\nqp = Matrix([[q1.diff(t)],\n [q2.diff(t)]])\n\n(Rational(1, 2)*qp.T*M*qp)[0].expand().trigsimp().factor(q1.diff(t), q2.diff(t))\n```\n\nEn este punto, introducimos una variable intermedia, tan solo para reducir un poco la notación:\n\n$$\n\\lambda = l \\sin{q_2}\n$$\n\ny su derivada con respecto al tiempo, la representamos como:\n\n$$\n\\dot{\\lambda} = \\lambda' \\dot{q}_2 \\implies \\lambda' = l \\cos{q_2}\n$$\n\npor lo que la energía cinetica queda como:\n\n$$\nK = \\frac{1}{2}\n\\begin{pmatrix}\n\\dot{q}_1 & \\dot{q}_2\n\\end{pmatrix}\n\\begin{pmatrix}\nm_1 + m_2 & -m_2 \\lambda \\\\\n-m_2 \\lambda & m_2 l^2\n\\end{pmatrix}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix}\n$$\n\nen donde el termino matricial es la matriz de masa $M(q)$ y $K(q, \\dot{q}) = \\dot{q}^T M(q) \\dot{q}$.\n\nPor otro lado, para calcular la energía potencial del sistema, tenemos que:\n\n$$\nU_1 = m_1 g h_1 = 0\n$$\n\n$$\nU_2 = m_2 g h_2 = m_2 g l \\sin{q_1} = m_2 g \\lambda\n$$\n\npor lo que la energía potencial del sistema será:\n\n$$\nU = m_2 g \\lambda\n$$\n\n\n```python\nu1 = 0\nu2 = m2*g*l*sin(q2)\nU = u1 + u2\nU\n```\n\nCuando aplicamos la primer condición de optimalidad al Lagrangiano $L(t, q(t), \\dot{q}(t)) = K(q(t), \\dot{q}(t)) - U(q)$, tenemos la ecuación de Euler-Lagrage, la cual nos dice que:\n\n$$\n\\frac{d}{dt} L_{\\dot{q}} - L_q = 0\n$$\n\npor lo que debemos encontrar la derivada del Lagrangiano, con respecto a $q$, $\\dot{q}$ y derivar esta ultima con respecto al tiempo. Empecemos con la derivada con respecto a $q$:\n\n$$\nL_q = K_q - U_q\n$$\n\nen donde:\n\n$$\n\\begin{align}\nK_q &= \\frac{\\partial}{\\partial q} \\left\\{ \\frac{1}{2} \\left[ (m_1 + m_2) \\dot{q}_1^2 + m_2 l^2 \\dot{q}_2^2 - 2 m_2 \\lambda \\dot{q}_1 \\dot{q}_2 \\right] \\right\\} \\\\\n&= \\frac{1}{2}\n\\begin{pmatrix}\n\\frac{\\partial}{\\partial q_1} \\left\\{ \\left[ (m_1 + m_2) \\dot{q}_1^2 + m_2 l^2 \\dot{q}_2^2 - 2 m_2 \\lambda \\dot{q}_1 \\dot{q}_2 \\right] \\right\\} \\\\\n\\frac{\\partial}{\\partial q_2} \\left\\{ \\left[ (m_1 + m_2) \\dot{q}_1^2 + m_2 l^2 \\dot{q}_2^2 - 2 m_2 \\lambda \\dot{q}_1 \\dot{q}_2 \\right] \\right\\}\n\\end{pmatrix} \\\\\n&= \\frac{1}{2}\n\\begin{pmatrix}\n0 \\\\\n- 2 m_2 \\lambda' \\dot{q}_1 \\dot{q}_2\n\\end{pmatrix} = - m_2 \\lambda'\n\\begin{pmatrix}\n0 & 0 \\\\\n\\dot{q}_2 & 0\n\\end{pmatrix}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix}\n\\end{align}\n$$\n\n\n```python\nKq = Matrix([[K.diff(q1)], [K.diff(q2)]])\nKq\n```\n\ny la derivada de la energía potencial con respecto a $q$:\n\n$$\nU_q = \\frac{\\partial}{\\partial q} \\left\\{ m_2 g \\lambda \\right\\} =\n\\begin{pmatrix}\n\\frac{\\partial}{\\partial q_1} \\left\\{ m_2 g \\lambda \\right\\} \\\\\n\\frac{\\partial}{\\partial q_2} \\left\\{ m_2 g \\lambda \\right\\}\n\\end{pmatrix} =\n\\begin{pmatrix}\n0 \\\\\nm_2 g \\lambda'\n\\end{pmatrix}\n$$\n\n\n```python\nUq = Matrix([[U.diff(q1)], [U.diff(q2)]])\nUq\n```\n\n\n```python\nLq = Kq - Uq\nLq\n```\n\nAhora obtenemos la derivada con respecto a $\\dot{q}$:\n\n$$\nL_{\\dot{q}} = K_{\\dot{q}} - U_{\\dot{q}}\n$$\n\nen donde:\n\n$$\nK_{\\dot{q}} = \\frac{1}{2} \\frac{\\partial}{\\partial \\dot{q}} \\left\\{ \\dot{q}^T M(q) \\dot{q} \\right\\} = M(q) \\dot{q}\n$$\n\n$$\nU_{\\dot{q}} = 0\n$$\n\n\n```python\nKqp = Matrix([[K.diff(q1.diff(t)).simplify()], [K.diff(q2.diff(t)).simplify()]])\nKqp\n```\n\n\n```python\nM*qp\n```\n\n\n```python\nUqp = Matrix([[U.diff(q1.diff(t)).simplify()], [U.diff(q2.diff(t)).simplify()]])\nUqp\n```\n\n\n```python\nLqp = Kqp - Uqp\nLqp\n```\n\nDerivando con respeto al tiempo estas ultimas expresiones, obtenemos:\n\n$$\n\\frac{d}{dt} K_{\\dot{q}} = \\dot{M}(q, \\dot{q}) \\dot{q} + M(q) \\ddot{q}\n$$\n\nen donde\n\n$$\n\\begin{align}\n\\dot{M}(q, \\dot{q}) &= \\frac{d}{dt} M(q) = \\frac{d}{dt}\n\\begin{pmatrix}\nm_1 + m_2 & -m_2 \\lambda \\\\\n-m_2 \\lambda & m_2 l^2\n\\end{pmatrix} \\\\\n&=\n\\begin{pmatrix}\n0 & -m_2 \\lambda' \\dot{q}_2 \\\\\n-m_2 \\lambda' \\dot{q}_2 & 0\n\\end{pmatrix} = -m_2 \\lambda'\n\\begin{pmatrix}\n0 & \\dot{q}_2 \\\\\n\\dot{q}_2 & 0\n\\end{pmatrix}\n\\end{align}\n$$\n\n\n```python\nM.diff(t)\n```\n\n\n```python\nqpp = qp.diff(t)\nqpp\n```\n\n\n```python\nM*qpp + M.diff(t)*qp\n```\n\n\n```python\nKqp.diff(t) - Uqp.diff(t)\n```\n\ny ya tenemos todos los elementos que integran nuestra ecuación de Euler-Lagrange:\n\n$$\n\\begin{align}\n\\frac{d}{dt} L_{\\dot{q}} - L_q &= 0 \\\\\nM(q) \\ddot{q} + \\dot{M}(q, \\dot{q}) \\dot{q} - K_q + U_q &= 0\n\\end{align}\n$$\n\n\n```python\nLqp.diff(t) - Lq\n```\n\nTan solo cabe recalcar que el segundo y tercer termino se pueden reducir a uno solo:\n\n$$\n\\begin{align}\n\\dot{M}(q, \\dot{q}) \\dot{q} - K_q &= -m_2 \\lambda'\n\\begin{pmatrix}\n0 & \\dot{q}_2 \\\\\n\\dot{q}_2 & 0\n\\end{pmatrix}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix} + m_2 \\lambda'\n\\begin{pmatrix}\n0 & 0 \\\\\n\\dot{q}_2 & 0\n\\end{pmatrix}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix} \\\\\n&= -m_2 \\lambda'\n\\begin{pmatrix}\n0 & \\dot{q}_2 \\\\\n0 & 0\n\\end{pmatrix}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix} = C(q, \\dot{q})\\dot{q}\n\\end{align}\n$$\n\nPor lo que finalmente tenemos:\n\n$$\nM(q) \\ddot{q} + C(q, \\dot{q}) \\dot{q} + U_q = 0\n$$\n\ncon:\n\n$$\nM(q) =\n\\begin{pmatrix}\nm_1 + m_2 & -m_2 \\lambda \\\\\n-m_2 \\lambda & m_2 l^2\n\\end{pmatrix} \\quad\nC(q, \\dot{q}) = -m_2 \\lambda'\n\\begin{pmatrix}\n0 & \\dot{q}_2 \\\\\n0 & 0\n\\end{pmatrix} \\quad\nU_q =\n\\begin{pmatrix}\n0 \\\\\nm_2 g \\lambda'\n\\end{pmatrix}\n$$\n\n\n```python\nC = Matrix([[0, -m2*l*cos(q2)*q2.diff(t)], [0, 0]])\nM*qpp + C*qp + Uq\n```\n\n## Comentario final del modelado\n\nSabemos que la energía total del sistema no cambia, es decir:\n\n$$\n\\frac{dE}{dt} = 0\n$$\n\ny la energía total del sistema es $E = K + U$, lo cual atraves de simplificación algebraica implica que:\n\n$$\n\\dot{q}^T \\left[ \\dot{M}(q, \\dot{q}) - 2 C(q, \\dot{q}) \\right] \\dot{q} = 0\n$$\n\npor lo que una manera relativamente sencilla de comprobar que nuestros calculos son correctos es comprobar que esta matriz sea antisimetrica:\n\n\n```python\nM.diff(t) - 2*C\n```\n\n## Simulación\n\nPara la simulación de este sistema podemos utilizar Simulink de MATLAB para introducir esta ecuación como un conjunto de bloques como los operadores matriciales e integradores. La formula que queremos usar es:\n\n$$\n\\ddot{q} = M^{-1}(q)\\left[ -C(q, \\dot{q}) \\dot{q} - U_q \\right]\n$$\n\nEl diagrama de bloques de esto se vería así:\n\n\n\nY una vez simulado esto, podemos guardar los datos de la simulación e importarlos aquí:\n\n\n```python\n# Se importa libreria de entrada y salida y se importan datos de simulacion en MATLAB\nimport scipy.io\ndatos = scipy.io.loadmat('./MATLAB/carropendulo.mat')\n```\n\n\n```python\n# Se importan datos de simulación a variables de Python para poder manipularlas\ndatos_q1 = datos.get(\"q1\")\ndatos_q2 = datos.get(\"q2\")\n```\n\n\n```python\nts, simq1 = zip(*datos_q1)\nts, simq2 = zip(*datos_q2)\nlen(simq1), len(simq2)\n```\n\nUna vez importados los datos podemos ingenuamente graficarlos y tendriamos los puntos por los que pasa las dos masas:\n\n\n```python\nfrom matplotlib.pyplot import plot, style, figure\nstyle.use(\"ggplot\")\n```\n\n\n```python\nfrom numpy import cos, sin, zeros, pi, arange, sqrt, linspace\n```\n\n\n```python\ntau = 2*pi\n```\n\n\n```python\nf = figure(figsize=(6, 6))\nplot(simq1 + cos(simq2), sin(simq2), \".\")\nplot(simq1, zeros(len(simq1)), \".\")\nax = f.gca()\nax.set_xlim(-0.5, 1.5)\nax.set_ylim(-1.5, 0.5);\nf.savefig('./imagenes/tray.png')\n```\n\n\n\nSin embargo es muy dificil encontrar un sentido físico a esto, ya que no vemos la trayectoria que sigue, por lo que podemos hacer algo aun mejor:\n\n\n```python\nfrom matplotlib import animation\nfrom matplotlib.patches import Rectangle, Circle\n```\n\n\n```python\n2.34*4\n```\n\n\n```python\nfig = figure(figsize=(6, 6))\n\nax = fig.add_subplot(111, autoscale_on=False,\n xlim=(-0.5, 1.5), ylim=(-1.5, 0.5))\n\nlinea, = ax.plot([], [], 'o-', lw=1.5, color='gray')\ncarro = Rectangle((10,10), 0.5, 0.25, lw=1.5, fc='white')\n\ndef init():\n linea.set_data([], [])\n carro.set_xy((-0.25, -0.125))\n ax.add_patch(carro)\n return linea, carro\n\ndef animate(i):\n thisy = [0, sin(simq2[i])]\n thisx = [simq1[i], simq1[i] + cos(simq2[i])]\n\n linea.set_data(thisx, thisy)\n carro.set_xy((simq1[i] - 0.25, -0.125))\n return linea, carro\n\nani = animation.FuncAnimation(fig, animate, arange(1, len(simq1)), interval=25,\n blit=True, init_func=init)\n\nani.save('./imagenes/pendulum.gif', writer='imagemagick');\n```\n\n\n\n¡Esto si parece un pendulo en un carro!\n\nPero aun no estamos satisfechos, podemos hacerlo incluso sin MATLAB, lo único que tenemos que hacer es incrementar la dimensión del sistema para reducir el orden de la ecuación diferencial.\n\nNuestro estado aumentado del sistema será:\n\n$$\n\\begin{pmatrix}\nq_1 \\\\\nq_2 \\\\\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix}\n$$\n\nPor lo que ahora tenemos que encontrar $f_1$, $f_2$, $f_3$ y $f_4$ tales que:\n\n$$\n\\begin{align}\n\\frac{d}{dt}q_1 &= f_1(q_1, q_2, \\dot{q}_1, \\dot{q}_2) \\\\\n\\frac{d}{dt}q_2 &= f_2(q_1, q_2, \\dot{q}_1, \\dot{q}_2) \\\\\n\\frac{d}{dt}\\dot{q}_1 &= f_3(q_1, q_2, \\dot{q}_1, \\dot{q}_2) \\\\\n\\frac{d}{dt}\\dot{q}_2 &= f_4(q_1, q_2, \\dot{q}_1, \\dot{q}_2) \\\\\n\\end{align}\n$$\n\nLas primeras dos ecuaciones son faciles:\n\n$$\n\\begin{align}\n\\frac{d}{dt}q_1 &= \\dot{q}_1 \\\\\n\\frac{d}{dt}q_2 &= \\dot{q}_2 \\\\\n\\end{align}\n$$\n\ny las otras dos, son las que ya teniamos:\n\n$$\n\\frac{d}{dt}\n\\begin{pmatrix}\n\\dot{q}_1 \\\\\n\\dot{q}_2\n\\end{pmatrix} =\n\\ddot{q} = M^{-1}(q)\\left[ -C(q, \\dot{q}) \\dot{q} - U_q \\right]\n$$\n\n\n```python\ndef f(estado, tiempo):\n from numpy import zeros\n from numpy import matrix\n \n m1 = 1\n m2 = 1\n g = 9.81\n l = 1\n \n q1, q2, q1p, q2p = estado\n \n q = matrix([[q1], [q2]])\n qp = matrix([[q1p], [q2p]])\n \n lam = l*sin(q2)\n lamp = l*cos(q2)\n \n M = matrix([[m1 + m2, -m2*lam], [-m2*lam, m2*l**2]])\n C = -m2*lamp*matrix([[0, q2p], [0, 0]])\n U = matrix([[0], [m2*g*lamp]])\n \n qpp = M.I*(-C*qp - U)\n \n dydx = zeros(4)\n \n dydx[0] = q1p\n dydx[1] = q2p\n dydx[2] = qpp[0]\n dydx[3] = qpp[1]\n \n return dydx\n```\n\n\n```python\nfrom scipy.integrate import odeint\n```\n\n\n```python\nts = linspace(0, 2.08, 100)\nestado_inicial = [0, 0, 0, 0]\n```\n\n\n```python\nestados = odeint(f, estado_inicial, ts)\nq1, q2 = estados[:, 0], estados[:, 1]\n```\n\n\n```python\nfig = figure(figsize=(8, 6))\n\nax = fig.add_subplot(111, autoscale_on=False,\n xlim=(-0.8333, 1.8333), ylim=(-1.25, 0.75))\n\nax.axes.get_xaxis().set_visible(False)\nax.axes.get_yaxis().set_visible(False)\n\nax.axes.spines[\"right\"].set_color(\"none\")\nax.axes.spines[\"left\"].set_color(\"none\")\nax.axes.spines[\"top\"].set_color(\"none\")\nax.axes.spines[\"bottom\"].set_color(\"none\")\n\nax.set_axis_bgcolor('#F2F1EC')\n\nlinea, = ax.plot([], [], 'o-', lw=1.5, color='#393F40')\ncarro = Rectangle((10,10), 0.8, 0.35, lw=1.5, fc='#E5895C')\nguia = Rectangle((10, 10), 2.6666, 0.1, lw=1.5, fc='#A4B187')\npendulo = Circle((10, 10), 0.125, lw=1.5, fc='#F3D966')\n\ndef init():\n linea.set_data([], [])\n guia.set_xy((-0.8333, -0.05))\n carro.set_xy((-0.4, -0.175))\n pendulo.center = (1, 0)\n ax.add_patch(guia)\n ax.add_patch(carro)\n ax.add_patch(pendulo)\n return linea, carro, pendulo\n\ndef animate(i):\n xs = [q1[i], q1[i] + cos(q2[i])]\n ys = [0, sin(q2[i])]\n\n linea.set_data(xs, ys)\n carro.set_xy((xs[0] - 0.4, ys[0] - 0.175))\n pendulo.center = (xs[1], ys[1])\n return linea, carro, pendulo\n\nani = animation.FuncAnimation(fig, animate, arange(1, len(q1)), interval=25,\n blit=True, init_func=init)\n\nani.save('./imagenes/pendulumpython.gif', writer='imagemagick');\n```\n\n\n\nEspero te hayas divertido con esta larga explicación y al final sepas un truco mas.\n\nSi deseas compartir este Notebook de IPython utiliza la siguiente dirección:\n\nhttp://bit.ly/1M2tenc\n\no bien el siguiente código QR:\n\n\n\n\n```python\n# Codigo para generar codigo :)\nfrom qrcode import make\nimg = make(\"http://bit.ly/1M2tenc\")\nimg.save(\"./codigos/carropendulo.jpg\")\n```\n", "meta": {"hexsha": "91169b2dc4c58bd8601d88782fb25571e937111a", "size": 97662, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "IPythonNotebooks/Control Optimo/Carro Pendulo.ipynb", "max_stars_repo_name": "robblack007/DCA", "max_stars_repo_head_hexsha": "0ea5f8b613e2dabe1127b857c7bfe9be64c52d20", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "IPythonNotebooks/Control Optimo/Carro Pendulo.ipynb", "max_issues_repo_name": "robblack007/DCA", "max_issues_repo_head_hexsha": "0ea5f8b613e2dabe1127b857c7bfe9be64c52d20", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "IPythonNotebooks/Control Optimo/Carro Pendulo.ipynb", "max_forks_repo_name": "robblack007/DCA", "max_forks_repo_head_hexsha": "0ea5f8b613e2dabe1127b857c7bfe9be64c52d20", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-03-20T12:44:13.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-20T12:44:13.000Z", "avg_line_length": 60.0258143823, "max_line_length": 4366, "alphanum_fraction": 0.7162253487, "converted": true, "num_tokens": 6575, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.37022537869825406, "lm_q2_score": 0.3276682876897044, "lm_q1q2_score": 0.12131111589732928}}
{"text": "# [ATM 623: Climate Modeling](../index.ipynb)\n\n[Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany\n\n# Lecture 7: Elementary greenhouse models\n\n### About these notes:\n\nThis document uses the interactive [`Jupyter notebook`](https://jupyter.org) format. The notes can be accessed in several different ways:\n\n- The interactive notebooks are hosted on `github` at https://github.com/brian-rose/ClimateModeling_courseware\n- The latest versions can be viewed as static web pages [rendered on nbviewer](http://nbviewer.ipython.org/github/brian-rose/ClimateModeling_courseware/blob/master/index.ipynb)\n- A complete snapshot of the notes as of May 2017 (end of spring semester) are [available on Brian's website](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2017/Notes/index.html).\n\n[Also here is a legacy version from 2015](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/Notes/index.html).\n\nMany of these notes make use of the `climlab` package, available at https://github.com/brian-rose/climlab\n\n\n```python\n# Ensure compatibility with Python 2 and 3\nfrom __future__ import print_function, division\n```\n\n## Contents\n\n1. [A single layer atmosphere](#section1)\n2. [Introducing the two-layer grey gas model](#section2)\n3. [Tuning the grey gas model to observations](#section3)\n4. [Level of emission](#section4)\n5. [Radiative forcing in the 2-layer grey gas model](#section5)\n6. [Radiative equilibrium in the 2-layer grey gas model](#section6)\n7. [Summary](#section7)\n\n____________\n
\n\n## 1. A single layer atmosphere\n____________\n\nWe will make our first attempt at quantifying the greenhouse effect in the simplest possible greenhouse model: a single layer of atmosphere that is able to absorb and emit longwave radiation.\n\n\n\n### Assumptions\n\n- Atmosphere is a single layer of air at temperature $T_a$\n- Atmosphere is **completely transparent to shortwave** solar radiation.\n- The **surface** absorbs shortwave radiation $(1-\\alpha) Q$\n- Atmosphere is **completely opaque to infrared** radiation\n- Both surface and atmosphere emit radiation as **blackbodies** ($\\sigma T_s^4, \\sigma T_a^4$)\n- Atmosphere radiates **equally up and down** ($\\sigma T_a^4$)\n- There are no other heat transfer mechanisms\n\nWe can now use the concept of energy balance to ask what the temperature need to be in order to balance the energy budgets at the surface and the atmosphere, i.e. the **radiative equilibrium temperatures**.\n\n\n### Energy balance at the surface\n\n\\begin{align}\n\\text{energy in} &= \\text{energy out} \\\\\n(1-\\alpha) Q + \\sigma T_a^4 &= \\sigma T_s^4 \\\\\n\\end{align}\n\nThe presence of the atmosphere above means there is an additional source term: downwelling infrared radiation from the atmosphere.\n\nWe call this the **back radiation**.\n\n### Energy balance for the atmosphere\n\n\\begin{align}\n\\text{energy in} &= \\text{energy out} \\\\\n\\sigma T_s^4 &= A\\uparrow + A\\downarrow = 2 \\sigma T_a^4 \\\\\n\\end{align}\n\nwhich means that \n$$ T_s = 2^\\frac{1}{4} T_a \\approx 1.2 T_a $$\n\nSo we have just determined that, in order to have a purely **radiative equilibrium**, we must have $T_s > T_a$. \n\n*The surface must be warmer than the atmosphere.*\n\n### Solve for the radiative equilibrium surface temperature\n\nNow plug this into the surface equation to find\n\n$$ \\frac{1}{2} \\sigma T_s^4 = (1-\\alpha) Q $$\n\nand use the definition of the emission temperature $T_e$ to write\n\n$$ (1-\\alpha) Q = \\sigma T_e^4 $$\n\n*In fact, in this model, $T_e$ is identical to the atmospheric temperature $T_a$, since all the OLR originates from this layer.*\n\nSolve for the surface temperature:\n$$ T_s = 2^\\frac{1}{4} T_e $$\n\nPutting in observed numbers, $T_e = 255$ K gives a surface temperature of \n$$T_s = 303 ~\\text{K}$$\n\nThis model is one small step closer to reality: surface is warmer than atmosphere, emissions to space generated in the atmosphere, atmosphere heated from below and helping to keep surface warm.\n\nBUT our model now overpredicts the surface temperature by about 15ºC (or K).\n\nIdeas about why?\n\nBasically we just need to read our **list of assumptions** above and realize that none of them are very good approximations:\n\n- Atmosphere absorbs some solar radiation.\n- Atmosphere is NOT a perfect absorber of longwave radiation\n- Absorption and emission varies strongly with wavelength *(atmosphere does not behave like a blackbody)*.\n- Emissions are not determined by a single temperature $T_a$ but by the detailed *vertical profile* of air temperture.\n- Energy is redistributed in the vertical by a variety of dynamical transport mechanisms (e.g. convection and boundary layer turbulence).\n\n\n\n____________\n
\n\n## 2. Introducing the two-layer grey gas model\n____________\n\nLet's generalize the above model just a little bit to build a slighly more realistic model of longwave radiative transfer.\n\nWe will address two shortcomings of our single-layer model:\n1. No vertical structure\n2. 100% longwave opacity\n\nRelaxing these two assumptions gives us what turns out to be a very useful prototype model for **understanding how the greenhouse effect works**.\n\n### Assumptions\n\n- The atmosphere is **transparent to shortwave radiation** (still)\n- Divide the atmosphere up into **two layers of equal mass** (the dividing line is thus at 500 hPa pressure level)\n- Each layer **absorbs only a fraction $\\epsilon$ ** of whatever longwave radiation is incident upon it.\n- We will call the fraction $\\epsilon$ the **absorptivity** of the layer.\n- Assume $\\epsilon$ is the same in each layer\n\nThis is called the **grey gas** model, where grey here means the emission and absorption have no spectral dependence.\n\nWe can think of this model informally as a \"leaky greenhouse\".\n\nNote that the assumption that $\\epsilon$ is the same in each layer is appropriate if the absorption is actually carried out by a gas that is **well-mixed** in the atmosphere.\n\nOut of our two most important absorbers:\n\n- CO$_2$ is well mixed\n- H$_2$O is not (mostly confined to lower troposphere due to strong temperature dependence of the saturation vapor pressure).\n\nBut we will ignore this aspect of reality for now.\n\nIn order to build our model, we need to introduce one additional piece of physics known as **Kirchoff's Law**:\n\n$$ \\text{absorptivity} = \\text{emissivity} $$\n\nSo if a layer of atmosphere at temperature $T$ absorbs a fraction $\\epsilon$ of incident longwave radiation, it must emit\n\n$$ \\epsilon ~\\sigma ~T^4 $$\n\nboth up and down.\n\n### A sketch of the radiative fluxes in the 2-layer atmosphere\n\n\n\n- Surface temperature is $T_s$\n- Atm. temperatures are $T_0, T_1$ where $T_0$ is closest to the surface.\n- absorptivity of atm layers is $\\epsilon$\n- Surface emission is $\\sigma T_s^4$\n- Atm emission is $\\epsilon \\sigma T_0^4, \\epsilon \\sigma T_1^4$ (up and down)\n- Absorptivity = emissivity for atmospheric layers\n- a fraction $(1-\\epsilon)$ of the longwave beam is **transmitted** through each layer\n\n### A fun aside: symbolic math with the `sympy` package\n\nThis two-layer grey gas model is simple enough that we can work out all the details algebraically. There are three temperatures to keep track of $(T_s, T_0, T_1)$, so we will have 3x3 matrix equations.\n\nWe all know how to work these things out with pencil and paper. But it can be tedious and error-prone. \n\nSymbolic math software lets us use the computer to automate a lot of tedious algebra.\n\nThe [sympy](http://www.sympy.org/en/index.html) package is a powerful open-source symbolic math library that is well-integrated into the scientific Python ecosystem. \n\n\n```python\nimport sympy\n# Allow sympy to produce nice looking equations as output\nsympy.init_printing()\n# Define some symbols for mathematical quantities\n# Assume all quantities are positive (which will help simplify some expressions)\nepsilon, T_e, T_s, T_0, T_1, sigma = \\\n sympy.symbols('epsilon, T_e, T_s, T_0, T_1, sigma', positive=True)\n# So far we have just defined some symbols, e.g.\nT_s\n```\n\n\n```python\n# We have hard-coded the assumption that the temperature is positive\nsympy.ask(T_s>0)\n```\n\n\n\n\n True\n\n\n\n### Longwave emissions\n\nLet's denote the emissions from each layer as\n\\begin{align}\nE_s &= \\sigma T_s^4 \\\\\nE_0 &= \\epsilon \\sigma T_0^4 \\\\\nE_1 &= \\epsilon \\sigma T_1^4 \n\\end{align}\n\nrecognizing that $E_0$ and $E_1$ contribute to **both** the upwelling and downwelling beams.\n\n\n```python\n# Define these operations as sympy symbols \n# And display as a column vector:\nE_s = sigma*T_s**4\nE_0 = epsilon*sigma*T_0**4\nE_1 = epsilon*sigma*T_1**4\nE = sympy.Matrix([E_s, E_0, E_1])\nE\n```\n\n### Shortwave radiation\nSince we have assumed the atmosphere is transparent to shortwave, the incident beam $Q$ passes unchanged from the top to the surface, where a fraction $\\alpha$ is reflected upward out to space.\n\n\n```python\n# Define some new symbols for shortwave radiation\nQ, alpha = sympy.symbols('Q, alpha', positive=True)\n# Create a dictionary to hold our numerical values\ntuned = {}\ntuned[Q] = 341.3 # global mean insolation in W/m2\ntuned[alpha] = 101.9/Q.subs(tuned) # observed planetary albedo\ntuned[sigma] = 5.67E-8 # Stefan-Boltzmann constant in W/m2/K4\ntuned\n# Numerical value for emission temperature\n#T_e.subs(tuned)\n```\n\n### Upwelling beam\n\nLet $U$ be the upwelling flux of longwave radiation. \n\nThe upward flux from the surface to layer 0 is\n$$ U_0 = E_s $$\n(just the emission from the suface).\n\n\n```python\nU_0 = E_s\nU_0\n```\n\nFollowing this beam upward, we can write the upward flux from layer 0 to layer 1 as the sum of the transmitted component that originated below layer 0 and the new emissions from layer 0:\n\n$$ U_1 = (1-\\epsilon) U_0 + E_0 $$\n\n\n```python\nU_1 = (1-epsilon)*U_0 + E_0\nU_1\n```\n\nContinuing to follow the same beam, the upwelling flux above layer 1 is\n$$ U_2 = (1-\\epsilon) U_1 + E_1 $$\n\n\n```python\nU_2 = (1-epsilon) * U_1 + E_1\n```\n\nSince there is no more atmosphere above layer 1, this upwelling flux is our Outgoing Longwave Radiation for this model:\n\n$$ OLR = U_2 $$\n\n\n```python\nU_2\n```\n\nThe three terms in the above expression represent the **contributions to the total OLR that originate from each of the three levels**. \n\nLet's code this up explicitly for future reference:\n\n\n```python\n# Define the contributions to OLR originating from each level\nOLR_s = (1-epsilon)**2 *sigma*T_s**4\nOLR_0 = epsilon*(1-epsilon)*sigma*T_0**4\nOLR_1 = epsilon*sigma*T_1**4\n\nOLR = OLR_s + OLR_0 + OLR_1\n\nprint( 'The expression for OLR is')\nOLR\n```\n\n### Downwelling beam\n\nLet $D$ be the downwelling longwave beam. Since there is no longwave radiation coming in from space, we begin with \n\n\n```python\nfromspace = 0\nD_2 = fromspace\n```\n\nBetween layer 1 and layer 0 the beam contains emissions from layer 1:\n\n$$ D_1 = (1-\\epsilon)D_2 + E_1 = E_1 $$\n\n\n```python\nD_1 = (1-epsilon)*D_2 + E_1\nD_1\n```\n\nFinally between layer 0 and the surface the beam contains a transmitted component and the emissions from layer 0:\n\n$$ D_0 = (1-\\epsilon) D_1 + E_0 = \\epsilon(1-\\epsilon) \\sigma T_1^4 + \\epsilon \\sigma T_0^4$$\n\n\n```python\nD_0 = (1-epsilon)*D_1 + E_0\nD_0\n```\n\nThis $D_0$ is what we call the **back radiation**, i.e. the longwave radiation from the atmosphere to the surface.\n\n____________\n
\n\n## 3. Tuning the grey gas model to observations\n____________\n\nIn building our new model we have introduced exactly one parameter, the absorptivity $\\epsilon$. We need to choose a value for $\\epsilon$.\n\nWe will tune our model so that it **reproduces the observed global mean OLR** given **observed global mean temperatures**.\n\nTo get appropriate temperatures for $T_s, T_0, T_1$, let's revisit the [global, annual mean lapse rate plot from NCEP Reanalysis data](Lecture06 -- Radiation.ipynb) from the previous lecture.\n\n### Temperatures\n\nFirst, we set \n$$T_s = 288 \\text{ K} $$\n\nFrom the lapse rate plot, an average temperature for the layer between 1000 and 500 hPa is \n\n$$ T_0 = 275 \\text{ K}$$\n\nDefining an average temperature for the layer between 500 and 0 hPa is more ambiguous because of the lapse rate reversal at the tropopause. We will choose\n\n$$ T_1 = 230 \\text{ K}$$\n\nFrom the graph, this is approximately the observed global mean temperature at 275 hPa or about 10 km.\n\n\n```python\n# add to our dictionary of values:\ntuned[T_s] = 288.\ntuned[T_0] = 275.\ntuned[T_1] = 230.\ntuned\n```\n\n### OLR\n\nFrom the [observed global energy budget](Lecture01 -- Planetary energy budget.ipynb) we set \n\n$$ OLR = 238.5 \\text{ W m}^{-2} $$\n\n### Solving for $\\epsilon$\n\nWe wrote down the expression for OLR as a function of temperatures and absorptivity in our model above. \n\nWe just need to equate this to the observed value and solve a **quadratic equation** for $\\epsilon$.\n\nThis is where the real power of the symbolic math toolkit comes in. \n\nSubsitute in the numerical values we are interested in:\n\n\n```python\n# the .subs() method for a sympy symbol means\n# substitute values in the expression using the supplied dictionary\n# Here we use observed values of Ts, T0, T1 \nOLR2 = OLR.subs(tuned)\nOLR2\n```\n\nWe have a quadratic equation for $\\epsilon$.\n\nNow use the `sympy.solve` function to solve the quadratic:\n\n\n```python\n# The sympy.solve method takes an expression equal to zero\n# So in this case we subtract the tuned value of OLR from our expression\neps_solution = sympy.solve(OLR2 - 238.5, epsilon)\neps_solution\n```\n\nThere are two roots, but the second one is unphysical since we must have $0 < \\epsilon < 1$.\n\nJust for fun, here is a simple of example of *filtering a list* using powerful Python *list comprehension* syntax:\n\n\n```python\n# Give me only the roots that are between zero and 1!\nlist_result = [eps for eps in eps_solution if 0
\n\n## 4. Level of emission\n____________\n\nEven in this very simple greenhouse model, there is **no single level** at which the OLR is generated.\n\nThe three terms in our formula for OLR tell us the contributions from each level.\n\n\n```python\nOLRterms = sympy.Matrix([OLR_s, OLR_0, OLR_1])\nOLRterms\n```\n\nNow evaluate these expressions for our tuned temperature and absorptivity:\n\n\n```python\nOLRtuned = OLRterms.subs(tuned)\nOLRtuned\n```\n\nSo we are getting about 67 W m$^{-2}$ from the surface, 79 W m$^{-2}$ from layer 0, and 93 W m$^{-2}$ from the top layer.\n\nIn terms of fractional contributions to the total OLR, we have (limiting the output to two decimal places):\n\n\n```python\nsympy.N(OLRtuned / 239., 2)\n```\n\nNotice that the largest single contribution is coming from the top layer. This is in spite of the fact that the emissions from this layer are weak, because it is so cold.\n\nComparing to observations, the actual contribution to OLR from the surface is about 22 W m$^{-2}$ (or about 9% of the total), not 67 W m$^{-2}$. So we certainly don't have all the details worked out yet!\n\nAs we will see later, to really understand what sets that observed 22 W m$^{-2}$, we will need to start thinking about the spectral dependence of the longwave absorptivity.\n\n____________\n\n[Back to ATM 623 notebook home](../index.ipynb)\n
\n\n____________\n## Version information\n____________\n\n\n\n```python\n%load_ext version_information\n%version_information sympy\n```\n\n Loading extensions from ~/.ipython/extensions is deprecated. We recommend managing extensions like any other Python packages, in site-packages.\n\n\n\n\n\nSoftware Version Python 3.7.3 64bit [Clang 4.0.1 (tags/RELEASE_401/final)] IPython 7.6.0 OS Darwin 17.7.0 x86_64 i386 64bit sympy 1.4 Wed Jul 03 14:50:34 2019 EDT
\n\n\n\n____________\n\n## Credits\n\nThe author of this notebook is [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n\nIt was developed in support of [ATM 623: Climate Modeling](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/), a graduate-level course in the [Department of Atmospheric and Envionmental Sciences](http://www.albany.edu/atmos/index.php)\n\nDevelopment of these notes and the [climlab software](https://github.com/brian-rose/climlab) is partially supported by the National Science Foundation under award AGS-1455071 to Brian Rose. Any opinions, findings, conclusions or recommendations expressed here are mine and do not necessarily reflect the views of the National Science Foundation.\n____________\n\n\n```python\n\n```\n", "meta": {"hexsha": "a554f97ba17e780fd50c8ad751fbe20857fba508", "size": 260008, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture07 -- Elementary greenhouse models.ipynb", "max_stars_repo_name": "adityarn/ClimateModeling_courseware", "max_stars_repo_head_hexsha": "f83e749c3428190204cf44ab414c8a5fdbba9e80", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lectures/Lecture07 -- Elementary greenhouse models.ipynb", "max_issues_repo_name": "adityarn/ClimateModeling_courseware", "max_issues_repo_head_hexsha": "f83e749c3428190204cf44ab414c8a5fdbba9e80", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture07 -- Elementary greenhouse models.ipynb", "max_forks_repo_name": "adityarn/ClimateModeling_courseware", "max_forks_repo_head_hexsha": "f83e749c3428190204cf44ab414c8a5fdbba9e80", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-07-28T16:16:05.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-28T16:16:05.000Z", "avg_line_length": 96.6572490706, "max_line_length": 12384, "alphanum_fraction": 0.829616781, "converted": true, "num_tokens": 7522, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.37387583672470853, "lm_q2_score": 0.32423539898095244, "lm_q1q2_score": 0.1212237810897733}}
{"text": "# Introduction\n\nWhat are we going to do ?\n\n\n Move Data into R -> Tranfrom it -> Visualise it -> Model it. \n\n\n## Before all that; what is **Jupyter** and how to use it ?\n\n\nJupyter documents are called \"notebooks\" and can be seen as many things at once. For example, notebooks allow:\n\n* coding in a standard web browser\n* direct sharing with results\n* using text with styles (such as italics and titles) to be explicitly marked using a wikitext language\n* easy creation and display of beautiful equations\n* easy creation and display of interactive visualizations\n\n\n\\begin{equation}\n e^{i\\pi} +1=0 \n\\end{equation}\n\n\n```R\nprint(\"nithin\")\n```\n\n [1] \"nithin\"\n\n\n\n### The . Green mode \nThis is the edit mode . Blue mode\nThis is the command mode here .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n```\n\n\n\nToggle cell visibility here .\n\n\n\n```python\n# Examples: \n# Factored form: 1/(x**2*(x**2 + 1))\n# Expanded form: 1/(x**4+x**2)\n\nimport sympy as sym\nfrom IPython.display import Latex, display, Markdown, Javascript, clear_output\nfrom ipywidgets import widgets, Layout # Interactivity module\n```\n\n## Partial fraction decomposition - Input by function\n\nWhen Laplace transform is used for system analysis, the Laplace transform of the output signal is obtained as a product of the transfer function and the Laplace transform of the input signal. The result of this multiplication can usually be quite difficult to comprehend. In order to execute the inverse Laplace transform we first perform the partial fraction decomposition. This example demonstrates this procedure.\n\n---\n\n### How to use this notebook?\nToggle between the option *Input by function* or *Input by polynomial coefficients*.\n\n1. *Input by function*:\n * Example: To insert the function $\\frac{1}{x^2(x^2 + 1)}$ (factored form) type 1/(x\\*\\*2\\*(x\\*\\*2 + 1)); to insert the same function in the expanded form ($\\frac{1}{x^4+x^2}$) type 1/(x\\*\\*4+x\\*\\*2).\n\n2. *Input by polynomial coefficients*:\n * Use the sliders to select the order of the numerator and denominator of a rational function of interest.\n * Insert the coefficients for both numerator and denominator in the dedicated textboxes and click *Confirm*.\n\n\n```python\n## System selector buttons\nstyle = {'description_width': 'initial'}\ntypeSelect = widgets.ToggleButtons(\n options=[('Input by function', 0), ('Input by polynomial coefficients', 1),],\n description='Select: ',style={'button_width':'230px'})\n\nbtnReset=widgets.Button(description=\"Reset\")\n\n# function\ntextbox=widgets.Text(description=('Insert the function:'),style=style)\nbtnConfirmFunc=widgets.Button(description=\"Confirm\") # ex btnConfirm\n\n# poly\nbtnConfirmPoly=widgets.Button(description=\"Confirm\") # ex btn\n\ndisplay(typeSelect)\n\ndef on_button_clickedReset(ev):\n display(Javascript(\"Jupyter.notebook.execute_cells_below()\"))\n\ndef on_button_clickedFunc(ev):\n eq = sym.sympify(textbox.value)\n\n if eq==sym.factor(eq):\n display(Markdown('Input function $%s$ is written in a factored form. ' %sym.latex(eq) + 'Its expanded form is $%s$.' %sym.latex(sym.expand(eq))))\n \n else:\n display(Markdown('Input function $%s$ is written in an expanded form. ' %sym.latex(eq) + 'Its factored form is $%s$.' %sym.latex(sym.factor(eq))))\n \n display(Markdown('The result of the partial fraction decomposition is: $%s$' %sym.latex(sym.apart(eq)) + '.'))\n display(btnReset)\n \ndef transfer_function(num,denom):\n num = np.array(num, dtype=np.float64)\n denom = np.array(denom, dtype=np.float64)\n len_dif = len(denom) - len(num)\n if len_dif<0:\n temp = np.zeros(abs(len_dif))\n denom = np.concatenate((temp, denom))\n transferf = np.vstack((num, denom))\n elif len_dif>0:\n temp = np.zeros(len_dif)\n num = np.concatenate((temp, num))\n transferf = np.vstack((num, denom))\n return transferf\n\ndef f(orderNum, orderDenom):\n global text1, text2\n text1=[None]*(int(orderNum)+1)\n text2=[None]*(int(orderDenom)+1)\n display(Markdown('2. Insert the coefficients of the numerator.'))\n for i in range(orderNum+1):\n text1[i]=widgets.Text(description=(r'a%i'%(orderNum-i)))\n display(text1[i])\n display(Markdown('3. Insert the coefficients of the denominator.')) \n for j in range(orderDenom+1):\n text2[j]=widgets.Text(description=(r'b%i'%(orderDenom-j)))\n display(text2[j])\n global orderNum1, orderDenom1\n orderNum1=orderNum\n orderDenom1=orderDenom\n\ndef on_button_clickedPoly(btn):\n clear_output()\n global num,denom\n enacbaNum=\"\"\n enacbaDenom=\"\"\n num=[None]*(int(orderNum1)+1)\n denom=[None]*(int(orderDenom1)+1)\n for i in range(int(orderNum1)+1):\n if text1[i].value=='' or text1[i].value=='Please insert a coefficient':\n text1[i].value='Please insert a coefficient'\n else:\n try:\n num[i]=int(text1[i].value)\n except ValueError:\n if text1[i].value!='' or text1[i].value!='Please insert a coefficient':\n num[i]=sym.var(text1[i].value)\n \n for i in range (len(num)-1,-1,-1):\n if i==0:\n enacbaNum=enacbaNum+str(num[len(num)-i-1])\n elif i==1:\n enacbaNum=enacbaNum+\"+\"+str(num[len(num)-i-1])+\"*x+\"\n elif i==int(len(num)-1):\n enacbaNum=enacbaNum+str(num[0])+\"*x**\"+str(len(num)-1)\n else:\n enacbaNum=enacbaNum+\"+\"+str(num[len(num)-i-1])+\"*x**\"+str(i) \n \n for j in range(int(orderDenom1)+1):\n if text2[j].value=='' or text2[j].value=='Please insert a coefficient':\n text2[j].value='Please insert a coefficient'\n else:\n try:\n denom[j]=int(text2[j].value)\n except ValueError:\n if text2[j].value!='' or text2[j].value!='Please insert a coefficient':\n denom[j]=sym.var(text2[j].value)\n \n for i in range (len(denom)-1,-1,-1):\n if i==0:\n enacbaDenom=enacbaDenom+\"+\"+str(denom[len(denom)-i-1])\n elif i==1:\n enacbaDenom=enacbaDenom+\"+\"+str(denom[len(denom)-i-1])+\"*x\"\n elif i==int(len(denom)-1):\n enacbaDenom=enacbaDenom+str(denom[0])+\"*x**\"+str(len(denom)-1)\n else:\n enacbaDenom=enacbaDenom+\"+\"+str(denom[len(denom)-i-1])+\"*x**\"+str(i)\n \n funcSym=sym.sympify('('+enacbaNum+')/('+enacbaDenom+')')\n\n DenomSym=sym.sympify(enacbaDenom)\n NumSym=sym.sympify(enacbaNum)\n DenomSymFact=sym.factor(DenomSym);\n funcFactSym=NumSym/DenomSymFact;\n \n if DenomSym==sym.expand(enacbaDenom):\n if DenomSym==DenomSymFact:\n display(Markdown('The function of interest is: $%s$. The numerator cannot be factored.' %sym.latex(funcSym)))\n else:\n display(Markdown('The function of interest is: $%s$. The numerator cannot be factored. The same function with the factored denominator can be written as: $%s$.' %(sym.latex(funcSym), sym.latex(funcFactSym))))\n\n if sym.apart(funcSym)==funcSym:\n display(Markdown('Partial fraction decomposition cannot be done.'))\n else:\n display(Markdown('The result of the partial fraction decomposition is: $%s$' %sym.latex(sym.apart(funcSym)) + '.'))\n \n btnReset.on_click(on_button_clickedReset)\n display(btnReset)\n \ndef partial_frac(index):\n\n if index==0:\n x = sym.Symbol('x') \n display(widgets.HBox((textbox, btnConfirmFunc)))\n btnConfirmFunc.on_click(on_button_clickedFunc)\n btnReset.on_click(on_button_clickedReset)\n \n elif index==1:\n display(Markdown('1. Define the order of the numerator (orderNum) and denominator (orderDenom).'))\n widgets.interact(f, orderNum=widgets.IntSlider(min=0,max=10,step=1,value=0),\n orderDenom=widgets.IntSlider(min=0,max=10,step=1,value=0));\n btnConfirmPoly.on_click(on_button_clickedPoly)\n display(btnConfirmPoly) \n\ninput_data=widgets.interactive_output(partial_frac,{'index':typeSelect})\ndisplay(input_data)\n```\n\n\n ToggleButtons(description='Select: ', options=(('Input by function', 0), ('Input by polynomial coefficients', …\n\n\n\n Output()\n\n", "meta": {"hexsha": "49983613fb92ed5cfd2c3fe0af38757269498ff9", "size": 11805, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_en/examples/02/.ipynb_checkpoints/TD-09-Partial-fraction-decomposition-checkpoint.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT/ENG/examples/02/TD-09-Partial-fraction-decomposition.ipynb", "max_issues_repo_name": "tuxsaurus/ICCT", "max_issues_repo_head_hexsha": "30d1aea4fb056c9736c9b4c5a0f50fff14fa6382", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT/ENG/examples/02/TD-09-Partial-fraction-decomposition.ipynb", "max_forks_repo_name": "tuxsaurus/ICCT", "max_forks_repo_head_hexsha": "30d1aea4fb056c9736c9b4c5a0f50fff14fa6382", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 38.3279220779, "max_line_length": 425, "alphanum_fraction": 0.532909784, "converted": true, "num_tokens": 2102, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268349147711747, "lm_q2_score": 0.25386101261427363, "lm_q1q2_score": 0.11999590979243142}}
{"text": "\n Métodos numéricos \n Segundo cuatrimestre 2021 \n Práctica 2: Esquemas temporales \n Cátedra: Pablo Dmitruk \n Fecha límite de entrega: 24 de septiembre de 2021 23:59 \n \n\n### Entrega de: **COMPLETAR CON SUS NOMBRES**\n\n- [Ejercicios](#ejercicios)\n\n- [Repaso teórico](#explicacion)\n\n\n $\\theta_0 = 0,1$, $\\dot \\theta_0 = 0$; \n $\\theta_0 = \\pi - 0,1$, $\\dot \\theta_0 = 0$; \n $\\theta_0 = \\pi$, $\\dot \\theta_0 = 0$; \n $\\theta_0 = 0$, $\\dot \\theta_0 = 2\\omega + 0,01$ ($2\\omega$ es la máxima diferencia de energía potencial gravitatoria entre dos puntos cualesquiera). \n \n\nLuego, para ambos métodos de Runge-Kutta, integre la ecuación para cada condición inicial fijando $\\omega_0 = 2$, $\\mu=0$, $k=10^{-3}$ y $t_f = 10$. Grafique la posición y la velocidad obtenidas. En todos los casos verifique que recupera el comportamiento esperado.\n\n\n```python\n# Posición y velocidad sin roce\n#-------------------------------\n# Figura y pares de ejes\nfig, axs = plt.subplots(2, 4, figsize=(16,4), constrained_layout=True)\n\ndt = # COMPLETAR: Paso temporal \n\n# Integrar para el primer conjunto de condiciones iniciales\nth_2 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK2\nth_4 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK4\n\n#-------------------------------------------------------------------------------\n# NO EDITAR ESTA SECCIÓN\n#-------------------------------------------------------------------------------\nt = np.arange(th_2.shape[0])*dt\naxs[0,0].plot(t, th_2[:,0], label=\"RK2\")\naxs[0,0].plot(t, th_4[:,0], label=\"RK4\")\naxs[1,0].plot(t, th_2[:,1], label=\"RK2\")\naxs[1,0].plot(t, th_4[:,1], label=\"RK4\")\nestetizar_graficos(axs[0,0], r\"$\\theta_0 = 0,1 \\ \\wedge \\ \\dot \\theta_0 = 0$\",\n \"$t$\", r\"$\\theta$\")\nestetizar_graficos(axs[1,0], \"\", \"$t$\", r\"$\\dot \\theta$\")\n#-------------------------------------------------------------------------------\n\n\n# Integrar para el segundo conjunto de condiciones iniciales\nth_2 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK2\nth_4 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK4\n\n#-------------------------------------------------------------------------------\n# NO EDITAR ESTA SECCIÓN\n#-------------------------------------------------------------------------------\nt = np.arange(th_2.shape[0])*dt\naxs[0,1].plot(t, th_2[:,0], label=\"RK2\")\naxs[0,1].plot(t, th_4[:,0], label=\"RK4\")\naxs[1,1].plot(t, th_2[:,1], label=\"RK2\")\naxs[1,1].plot(t, th_4[:,1], label=\"RK4\")\nestetizar_graficos(axs[0,1], r\"$\\theta_0 = \\pi-0,1 \\ \\wedge \\ \\dot \\theta_0=0$\",\n \"$t$\", r\"$\\theta$\")\nestetizar_graficos(axs[1,1], \"\", \"$t$\", r\"$\\dot \\theta$\")\n#-------------------------------------------------------------------------------\n\n\n# Integrar para el tercer conjunto de condiciones iniciales\nth_2 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK2\nth_4 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK4\n\n#-------------------------------------------------------------------------------\n# NO EDITAR ESTA SECCIÓN\n#-------------------------------------------------------------------------------\nt = np.arange(th_2.shape[0])*dt\naxs[0,2].plot(t, th_2[:,0], label=\"RK2\")\naxs[0,2].plot(t, th_4[:,0], label=\"RK4\")\naxs[1,2].plot(t, th_2[:,1], label=\"RK2\")\naxs[1,2].plot(t, th_4[:,1], label=\"RK4\")\nestetizar_graficos(axs[0,2], r\"$\\theta_0 = \\pi \\ \\wedge \\ \\dot \\theta_0 = 0$\",\n \"$t$\", r\"$\\theta$\")\nestetizar_graficos(axs[1,2], \"\", \"$t$\", r\"$\\dot \\theta$\")\n#-------------------------------------------------------------------------------\n\n# Integrar para el cuarto conjunto de condiciones iniciales\nth_2 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK2\nth_4 = # COMPLETAR: guardar en th_2 el resultado de integrar con RK4\n\n#-------------------------------------------------------------------------------\n# NO EDITAR ESTA SECCIÓN\n#-------------------------------------------------------------------------------\nt = np.arange(th_2.shape[0])*dt\naxs[0,3].plot(t, th_2[:,0], label=\"RK2\")\naxs[0,3].plot(t, th_4[:,0], label=\"RK4\")\naxs[1,3].plot(t, th_2[:,1], label=\"RK2\")\naxs[1,3].plot(t, th_4[:,1], label=\"RK4\")\nestetizar_graficos(axs[0,3], r\"$\\theta_0 = 0 \\ \\wedge \\ \" +\\\n r\"\\dot \\theta_0 = 2\\omega_0 + 0,01$\", \"$t$\", r\"$\\theta$\")\nestetizar_graficos(axs[1,3], \"\", \"$t$\", r\"$\\dot \\theta$\");\n```\n\n### Conservación de la energía\nAdemás de verificar que el movimiento, cualitativamente, es consistente con nuestro conocimiento físico, para el caso sin roce sabemos que debe conservarse la energía mecánica, que podemos definir como\n\\begin{equation*}\n E(t) = \\dot \\theta(t)^2 + 4 \\omega_0^2 \\mathrm{sen}^2\\left(\\frac{\\theta(t)}{2} \\right).\n\\end{equation*}\n\n$\\text{d)}$ Escriba una función `energia` que reciba como valores de entrada a $\\theta$, $\\dot \\theta$ y $\\omega_0$ y devuelva la energía mecánica para cada instante. Usando esta función verifique que a todo tiempo se verifica aproximadamente la conservación de la energía, es decir, $|\\Delta E| = |E(t) - E(0)| \\ll 1$, para todos los casos estudiados en el inciso anterior, considerando esta vez $t_f=75$.\n\n\n```python\n# Estudio de conservación de energía para el caso sin rozamiento\n\ndef energia(th, omega):\n \"\"\"\n Calcula la energía mecánica para todo tiempo.\n \n Entrada:\n - th: Arreglo de forma (N,2) con la posición ([:,0]) y\n la velocidad angular ([:,1]).\n - omega_0: Frecuencia natural del sistema.\n \n Salida:\n - energia: Arreglo de forma (N).\n \"\"\"\n # COMPLETAR\n\n return energia\n\n# Figuras, pares de ejes y paso temporal\nfig, axs = plt.subplots(1, 4, figsize=(16,4), constrained_layout=True)\ndt = 1e-3\noffset = int(2/1e-3)\n\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK2\n# para el primer conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_2.\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK4\n# para el primer conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_4.\n\n# ----------------------------- NO EDITAR --------------------------------------\nt = np.arange(0, DeltaE_2.shape[0])*dt\naxs[0].semilogy(t[offset:], DeltaE_2[offset:], label=\"RK2\")\naxs[0].semilogy(t[offset:], DeltaE_4[offset:], label=\"RK4\")\nestetizar_graficos(axs[0], r\"$\\theta_0 = 0,1 \\ \\wedge \\ \\dot{\\theta}_0 = 0$\",\n \"$t$\", r\"$|\\Delta E|$\")\n# ------------------------------------------------------------------------------\n\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK2\n# para el segundo conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_2.\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK4\n# para el segundo conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_4.\n\n# ----------------------------- NO EDITAR --------------------------------------\nt = np.arange(0, DeltaE_2.shape[0])*dt\naxs[1].semilogy(t[offset:], DeltaE_2[offset:], label=\"RK2\")\naxs[1].semilogy(t[offset:], DeltaE_4[offset:], label=\"RK4\")\nestetizar_graficos(axs[1], r\"$\\theta_0 = \\pi-0,1 \\ \\wedge \\ \\dot{\\theta}_0 = 0$\",\n \"$t$\", r\"$|\\Delta E|$\")\n# ------------------------------------------------------------------------------\n\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK2\n# para el tercer conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_2.\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK4\n# para el tercer conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_4.\n\n# ----------------------------- NO EDITAR --------------------------------------\nt = np.arange(0, DeltaE_2.shape[0])*dt\naxs[2].semilogy(t[offset:], DeltaE_2[offset:], label=\"RK2\")\naxs[2].semilogy(t[offset:], DeltaE_4[offset:], label=\"RK4\")\nestetizar_graficos(axs[2], r\"$\\theta_0 = \\pi \\ \\wedge \\ \\dot{\\theta}_0 = 0$\",\n \"$t$\", r\"$|\\Delta E|$\")\n# ------------------------------------------------------------------------------\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK2\n# para el cuarto conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_2.\n\n# COMPLETAR: Calcular la variación de energía para todo instante usando RK4\n# para el cuarto conjunto de condiciones iniciales y asignarla a la variable\n# DeltaE_4.\n\n# ----------------------------- NO EDITAR --------------------------------------\nt = np.arange(0, DeltaE_2.shape[0])*dt\naxs[3].semilogy(t[offset:], DeltaE_2[offset:], label=\"RK2\")\naxs[3].semilogy(t[offset:], DeltaE_4[offset:], label=\"RK4\")\nestetizar_graficos(axs[3], rr\"$\\theta_0 = 0 \\ \\wedge \\ \" +\\\n r\"\\dot \\theta_0 = 2\\omega_0 + 0,01$\", \"$t$\", r\"$|\\Delta E|$\");\n# ------------------------------------------------------------------------------\n```\n\n### Reproducción del período real\nTambién usando la conservación de la energía, y si el movimiento parte del reposo, podemos obtener una expresión analítica para el período del movimiento:\n\\begin{equation*}\n T = \\frac{4}{\\omega} K\\left( \\mathrm{sen}^2\\left( \\frac{\\theta_0}{2}\\right)\\right),\n\\end{equation*}\ndonde $\\theta_0$ es la posición inicial y $K$ la integral elíptica completa de primera especie.\n\n$\\text{e)}$ Para cada integrador temporal, calcule la diferencia entre el período dado por la expresión analítica y el que obtiene a partir de sus simulaciones para el conjunto de posiciones iniciales $[\\boldsymbol \\theta_0]_j = 0,01 + j\\Delta \\theta_0$, $0 \\le j < 20$ y $\\Delta \\theta_0 = 0,1234$ (es decir 20 puntos equiespaciados entre $0,01$ y $3\\pi/4$). En todos los casos considere nula a la velocidad angular inicial. Analice en particular los siguientes casos:\n\n $ \\omega_0 = 1, \\ \\mu=0, \\ k=1 \\times 10^{-2},\\ t_f = 250 $; \n $ \\omega_0 = 10, \\ \\mu=0, \\ k=1 \\times 10^{-2},\\ t_f = 250 $; \n $ \\omega_0 = 10, \\ \\mu=0, \\ k=1 \\times 10^{-3},\\ t_f = 250 $. \n \n\nComo ayuda le proporcionamos funciones que calculan ambos períodos.\n\n\n```python\ndef periodo_analitico(th0, omega0):\n \"\"\"\n Calcula el período del péndulo sin roce dada la posición inicial y la\n frecuencia natural del sistema.\n\n Entradas:\n - th0: Número de punto flotante con la posición inicial de la masa.\n - omega0: Frecuencia natural del sistema.\n \n Salida:\n - Período del péndulo.\n \"\"\"\n import scipy.special as spspecial\n return 4/omega0*spspecial.ellipk(np.sin(th0/2)**2)\n\ndef periodo_datos(th, dt):\n \"\"\"\n Calcula el período del péndulo sin roce dada una serie de posiciones\n theta(t) y el paso temporal entre muestras.\n\n Entradas:\n - th: Vector de N elementos con la posición de la masa para N instantes\n consecutivos.\n - dt: Espaciamemiento entre muestras.\n \n Salida:\n - Período del péndulo.\n \"\"\" \n import scipy.signal as spsignal\n \n # Uso una ventana de Blackman-Harris para reducir Gibbs\n con_ventana = th*spsignal.blackmanharris(th.size)\n \n # Relleno con ceros para interpolar el espectro\n ceros = 10000\n T_previo = 0\n T_actual = 1\n\n # Pruebo distintos niveles de relleno hasta converger 3 dígitos decimales\n while np.abs((T_previo-T_actual)/T_actual) > 1e-3:\n ceros = 2*ceros\n relleno = np.pad(con_ventana, ceros, mode=\"constant\")\n RELLENO = np.fft.rfft(relleno)\n f = np.fft.rfftfreq(relleno.size, d=dt)\n\n # Busco el pico de la FFT y saco la frecuencia del pico. Transformo a T.\n ind = np.argmax(np.abs(RELLENO))\n T_previo = T_actual\n T_actual = 1/f[ind]\n\n return T_actual\n\n# Figura y pares de ejes\nfig, axs = plt.subplots(1, 3, figsize=(12,4), constrained_layout=True)\n\n# Vector de tiempos\ndt, tf = 1e-2, 250\npasos = int(round(tf/dt))\nt = np.arange(0, pasos+1)*dt\n\n# Conjunto de condiciones iniciales y diferencias de periodos\nN = 20\nconds_ini = np.linspace(1e-2, 3*np.pi/4, N)\nDeltaT_2 = np.zeros(N)\nDeltaT_4 = np.zeros(N)\n\n# Períodos para omega_0 = 1\nfor n, ini in enumerate(conds_ini):\n # COMPLETAR: Obtener la diferencia de períodos para la condicion inicial\n # actual y guardarlos en DeltaT_2[n] (para RK2) y DeltaT_4[n] (para RK4).\n\n# -------------------- NO EDITAR ESTA SECCIÓN ----------------------------------\naxs[0].plot(conds_ini, DeltaT_2, \"x\", c=\"C0\", label=\"RK2\", markersize=10)\naxs[0].plot(conds_ini, DeltaT_4, \"o\", c=\"C1\", label=\"RK4\")\nestetizar_graficos(axs[0], r\"$\\omega_0=1, \\ \\Delta t=1\\times 10^{-2}$\",\n r\"$\\theta_0$\", \"$T$\")\n# ------------------------------------------------------------------------------\n\n\n# Períodos para omega_0 = 10\nfor n, ini in enumerate(conds_ini):\n # COMPLETAR: Obtener la diferencia de períodos para la condicion inicial\n # actual y guardarlos en DeltaT_2[n] (para RK2) y DeltaT_4[n] (para RK4).\n\n# -------------------- NO EDITAR ESTA SECCIÓN ----------------------------------\naxs[1].plot(conds_ini, DeltaT_2, \"x\", c=\"C0\", label=\"RK2\", markersize=10)\naxs[1].plot(conds_ini, DeltaT_4, \"o\", c=\"C1\", label=\"RK4\")\nestetizar_graficos(axs[1], r\"$\\omega_0=10, \\ \\Delta t=1\\times 10^{-2}$\",\n r\"$\\theta_0$\", \"$T$\")\n# ------------------------------------------------------------------------------\n\n# Vector de tiempos\ndt, tf = 1e-3, 250\npasos = int(round(tf/dt))\nt = np.arange(0, pasos+1)*dt\n\n\n# Períodos para omega0 = 10 con k más chico\nfor n, ini in enumerate(conds_ini):\n # COMPLETAR: Obtener la diferencia de períodos para la condicion inicial\n # actual y guardarlos en DeltaT_2[n] (para RK2) y DeltaT_4[n] (para RK4).\n\n# -------------------- NO EDITAR ESTA SECCIÓN ----------------------------------\naxs[2].plot(conds_ini, DeltaT_2, \"x\", c=\"C0\", label=\"RK2\", markersize=10)\naxs[2].plot(conds_ini, DeltaT_4, \"o\", c=\"C1\", label=\"RK4\")\nestetizar_graficos(axs[2], r\"$\\omega_0=10, \\ \\Delta t=1 \\times 10^{-3}$\",\n r\"$\\theta_0$\", \"$T$\");\n# ------------------------------------------------------------------------------\n```\n\n**Nota**: La celda anterior puede tardar entre 5 y 10 minutos en ejecutarse. Intente reducir la cantidad de condiciones iniciales `N` a 2 o 3 hasta estar seguro de estar obteniendo resultados razonables.\n\n### Posición y velocidad con roce\n\nObtenidos resultados satisfactorios en los incisos previos, pueden tener ya una cierta confianza en que los integradores que escribieron evolucionan aceptablemente el término no lineal. Resta realizar algunas pruebas para ver que los resultados para los casos con roce también se ajustan a lo esperado.\n\n$\\text{f)}$ Considerando $\\theta_0=0,01$, $\\omega_0 = 1$, $k=10^{-2}$, $t_f=100$ y para ambos integradores temporales, integre en tiempo los casos:\n\n$\\mu = 0,1$ (amortiguamiento subcrítico); \n$\\mu = 10$ (amortiguamiento supercrítico). \n \n\nVerifique que, cualitativamente, la posición y la velocidad angular presentan el comportamientos esperados.\n\n\n\n```python\n# Figura, pares de ejes y parámetros temporales\nfig, axs = plt.subplots(2, 2, figsize=(8,8), constrained_layout=True)\ndt, tf = 1e-2, 100\n\n# COMPLETAR: Con las soluciones para RK2 (th_2) y RK4 (th_4) en el caso\n# mu = 0,1.\nth_2 = #...\nth_4 = #...\n\n# --------------------------- NO EDITAR ESTA SECCIÓN ---------------------------\nt = np.arange(0, th_2.shape[0])*dt\naxs[0,0].plot(t, th_2[:,0], label=\"RK2\")\naxs[0,0].plot(t, th_4[:,0], label=\"RK4\")\nestetizar_graficos(axs[0,0], \"Amortiguamiento subcrítico\", \"$t$\", r\"$\\theta$\")\naxs[1,0].plot(t, th_2[:,1], label=\"RK2\")\naxs[1,0].plot(t, th_4[:,1], label=\"RK4\")\nestetizar_graficos(axs[1,0], \"\", \"$t$\", r\"$\\dot\\theta$\")\n# ------------------------------------------------------------------------------\n\n\n# COMPLETAR: Con las soluciones para RK2 (th_2) y RK4 (th_4) en el caso\n# mu = 10\nth_2 = #...\nth_4 = #...\n\n# --------------------------- NO EDITAR ESTA SECCIÓN ---------------------------\nt = np.arange(0, th_2.shape[0])*dt\naxs[0,1].plot(t, th_2[:,0], label=\"RK2\")\naxs[0,1].plot(t, th_4[:,0], label=\"RK4\")\nestetizar_graficos(axs[0,1], \"Amortiguamiento supercrítico\", \"$t$\", r\"$\\theta$\")\naxs[1,1].plot(t, th_2[:,1], label=\"RK2\")\naxs[1,1].plot(t, th_4[:,1], label=\"RK4\")\nestetizar_graficos(axs[1,1], \"\", \"$t$\", r\"$\\dot\\theta$\");\n# ------------------------------------------------------------------------------\n```\n\n### Balance entre pérdida de energía mecánica y potencia disipada\n\nEn términos de energía mecánica ya no vamos a tener conservación para el caso con disipación. Sin embargo, resulta sencillo derivar la siguiente ecuación de balance\n\\begin{equation*}\n \\dot E (t) = - \\mu \\dot \\theta^2(t) = P_\\mu(t),\n\\end{equation*}\ndonde $P_\\mu$ es la potencia disipada por la fuerza de roce.\n\n$\\text{g)}$ Para los casos estudiados en el inciso anterior, verifique si se verifica (de manera aproximada) la ecuación de balance mencionada. Para ello, grafique la cantidad $|\\dot{E} - P_\\mu|$ en función del tiempo.\n\n\n```python\n# Balance variación de energía - disipación\ndef potencia_roce(th_punto, mu):\n \"\"\"\n Calcula la potencia entregada/disipada al sistema por el roce con el aire.\n\n Entrada:\n - th_punto: Arreglo de (N) elementos con la velocidad angular de la\n masa para N instantes de tiempo.\n - mu: Coeficiente de la fuerza de rozamiento (en unidades de frecuencia)\n \n Salida:\n - potencia: Arreglo de (N) elementos con la potencia entregada/disipada\n por la fuerza de roce a cada instante.\n \"\"\"\n return # COMPLETAR\n\ndef variacion_energia(energia, dt):\n \"\"\"\n Calcula la variación temporal de la energía mecánica usando diferencias\n finitas centradas de 6to orden. En los extremos del intervalo, donde no se\n tienen suficientes datos, se devuelve 0.\n\n Entrada:\n - energia: Arreglo de (N) elementos con la energía mecánica para N\n N instantes consecutivos.\n - dt: Espaciamiento entre muestras de la energía mecánica.\n \n Salida:\n - var: Arreglo de (N) elementos con la variación temporal de la energía\n mecánica.\n \"\"\"\n var = np.zeros_like(energia)\n var = -1*np.roll(energia, 3) + 9*np.roll(energia, 2)\n var += -45*np.roll(energia, 1) + 45*np.roll(energia, -1)\n var += -9*np.roll(energia, -2) + np.roll(energia, -3)\n var = var/(60*dt)\n var[-3:] = 0\n var[:3] = 0\n return var\n\n# Figuras, pares de ejes y paso temporal\nfig, axs = plt.subplots(1, 2, figsize=(8,4), constrained_layout=True)\ndt = 1e-2\noffset = int(round(2/dt))\n\n# Integración para mu = 0,1\n\n# COMPLETAR: Calcular el valor absoluto de la diferencia entre la variación\n# de energía y la potencia disipada. Guarde sus resultados en las variables\n# bal_2 (para la integración de segundo orden) y bal_4 (para la de cuarto).\n\n# --------------------------- NO EDITAR ESTA SECCIÓN ---------------------------\nt = np.arange(bal_2.shape[0])*dt\naxs[0].semilogy(t[offset:], bal_2[offset:], label=\"RK2\")\naxs[0].semilogy(t[offset:], bal_4[offset:], label=\"RK4\")\nestetizar_graficos(axs[0], \"Amortiguamiento subcrítico\",\n \"$t$\", r\"$|\\partial_t E - P_\\mu|$\")\n# ------------------------------------------------------------------------------\n\n# Integración para mu = 10\n\n# COMPLETAR: Calcular el valor absoluto de la diferencia entre la variación\n# de energía y la potencia disipada. Guarde sus resultados en las variables\n# bal_2 (para la integración de segundo orden) y bal_4 (para la de cuarto).\n\n# --------------------------- NO EDITAR ESTA SECCIÓN ---------------------------\nt = np.arange(bal_2.shape[0])*dt\naxs[1].semilogy(t[offset:], bal_2[offset:], label=\"RK2\")\naxs[1].semilogy(t[offset:], bal_4[offset:], label=\"RK4\")\nestetizar_graficos(axs[1], \"Amortiguamiento supercrítico\",\n \"$t$\", r\"$|\\partial_t E - P_\\mu|$\")\n# ------------------------------------------------------------------------------\n```\n\n### Análisis de resultados\n\n$\\text{h)}$ Describa **brevemente** los resultados obtenidos en los incisos anteriores.\n\n**Su resolución acá**\n\n---\n\n---\n\nMétodos multipaso lineales **: en forma similar a lo que hacíamos con diferencias finitas, se propone $y^{n+1}$ como función de múltiples valores $y^j$ y $f^j$, en lugar de usar solo $y^n$ y $f^n/f^{n+1}$ como hicimos para los métodos de Euler.\n- **Métodos predictores-correctores **: generan una solución aproximada a partir de métodos de bajo orden (la _predicción_) que luego es mejorada usando algún algoritmo de interpolación (la _corrección_).\n- **Métodos de Runge-Kutta **: utilizan, en lugar de valores de $y$ y de $f$ para pasos previos/posteriores, valores intermedios de $f$, como por ejemplo $f^{n+\\frac{1}{2}} = f\\left(t^n + \\frac{k}{2}, y\\left(t^n+\\frac{k}{2}\\right)\\right)$. Pueden verse como un caso de métodos predictores-correctores, aunque su uso extendido hace que reciban una denominación propia.\n\nVeamos, antes de pasar a considerar en detalle estas estrategias, por qué nos concentraremos solo en integrar $y$ a partir de su derivada primera $\\dot y$. Spoiler: una EDO de orden $N$ puede reducirse a un sistema de $N$ EDOs de primer orden. Vale notar, sin embargo, que existen integradores temporales para EDOs de orden superior, aunque no los veremos en el curso. Cuando en prácticas posteriores veamos ecuaciones en derivadas parciales EDPs, trabajar con integradores para la primer derivada temporal tampoco resultará un limitante, como oportunamente mostraremos.\n\n### **Reducción de dimensionalidad de una EDO (ecuación diferencial ordinaria)**\n\nSi bien en la materia solo veremos integradores temporales para sistemas de EDOs de primer orden, esto no representa restricción alguna con respecto a los problemas que podremos resolver. Como probablemente hayan visto en materias anteriores, cualquier EDO de orden $N$ puede reescribirse como un sistema de $N$ EDOs de primer orden. La manera más simple de verlo es con un ejemplo. Dada el problema de valores iniciales de orden 2\n\\begin{equation*}\n \\dot{y} \\ddot{y}\\cos(t) + t^2\\dot{y}^2 = y \\ln(y), \\qquad y(t_0) = y_0 \\quad \\wedge \\quad \\dot{y}(t_0) = \\dot{y}_0,\n\\end{equation*}\npodemos substituir $u_1 = y$, $u_2 = \\dot y$, y de esta manera tenemos el sistema\n\\begin{align*}\n \\dot{u}_1 &= u_2, \\qquad \\qquad &&u_1(t_0) = y_0, \\\\\n \\dot{u}_2 &= \\frac{u_1 \\ln(u_1)- t^2 u_2^2}{u_2 \\cos(t)}, \\qquad \\qquad &&u_2(t_0) = \\dot{y}_0,\n\\end{align*}\nque es un sistema de 2 ecuaciones diferenciales de primer orden acopladas expresable como\n\\begin{align*}\n \\dot{\\mathbf{u}} &= \\mathbf{F}(t, \\mathbf{u}), \\\\ \\mathbf{u}(t_0) &= \\mathbf{u_0},\n\\end{align*}\ncon\n\\begin{equation*}\n\\mathbf{u} = \\begin{pmatrix}\n u_1 \\\\\n u_2 \\\\\n\\end{pmatrix}, \\qquad \\mathbf{u}_0=\\begin{pmatrix}\n y_0\\\\\n \\dot{y}_0\n\\end{pmatrix}, \\qquad \\mathbf{F}=\\begin{pmatrix}\n u_2 \\\\\n \\dfrac{u_1 \\ln(u_1) - t^2 u_2^2}{u_2 \\cos(t)}\n \\end{pmatrix}.\n\\end{equation*}\n\nVemos entonces que, reescribiendo nuestro problema, los métodos que veremos a continuación resultan fácilmente aplicables a ecuaciones de órdenes superiores. Además, para alivianar la notación, presentaremos los esquemas de integración temporal considerando una única EDO de primer orden. Sin embargo, todos los métodos son fácilmente generalizables a sistemas de EDOs, como veremos al final con un ejemplo.\n\n### **Métodos multipaso lineales**\n\nEste tipo de métodos se llaman lineales ya que proponen una combinación lineal (de allí el nombre lineal) de $y^j$ y $f^j$ usando información correspondiente a varios pasos temporales (de allí el nombre multipaso). Esto quiere decir que, en general, podemos escribirlos para un cierto tiempo $t^n$ como\n\\begin{equation*}\n \\sum_{j=0}^s \\alpha^j y^{n+j} = k \\sum_{j=0}^s \\beta^j f^{n+j}, \\tag{1}\n\\end{equation*}\ndando valores específicos de $\\boldsymbol \\alpha$ y $\\boldsymbol \\beta$ a realizaciones particulares de métodos multipaso lineales. Si bien a simple vista la elección de $\\boldsymbol \\alpha$ y $\\boldsymbol \\beta$ puede parecer trivial, i.e. ajustar los $2s+2$ grados de libertad de forma de obtener esquemas de orden $\\mathcal{O}(k^{2s})$, si buscamos obtener integradores estables (veremos por qué son los únicos que nos interesan más adelante), el mayor orden de aproximación que podemos obtener con la ecuación $(1)$ es $\\mathcal{O}(k^{s+2})$ (Teorema de Dahlquist). De esta manera, aparecen muchas propuestas de cómo ajustar los correspondientes $s$ grados de libertad.\n\n**Una dificultad que presentan los métodos multipaso es que**, por construcción, **resulta necesario conocer $y^j$ y $f^j$ para múltiples instantes**, información con la que no contamos si solo disponemos de una condición inicial $y^0$. **En la práctica, una manera usual de resolver esto es inicializar la integración con otro método** (ej: Euler con alta resolución temporal — de forma de mantener el orden de aproximación—, Runge-Kutta, predictor-corrector, etc.). Una vez contamos con la cantidad de pasos suficientes comenzamos la aplicación del método multipaso deseado.\n\nEn la práctica de la materia veremos dos familias de métodos multipaso lineales: los métodos de **Adams-Bashforth** (explícitos) y los de **Adams-Moulton** (implícitos). Ambos métodos en su conjunto se conocen como métodos de _Adams_$^\\dagger$ y están dados por la expresión\n\\begin{equation*}\n y^{n+s} - y^{n+s-1} = k\\sum_{j=0}^s \\beta^j f^{n+j},\n\\end{equation*}\nes decir, surgen de escoger $\\alpha_0, \\dots, \\alpha_{s-2} = 0$, $\\alpha_{s-1} = -1$ y $\\alpha_s = 1$.\n\n$^\\dagger$: el mismo Adams que postuló por primera vez la existencia de Neptuno.\n\n#### **Adams-Bashforth**\n\nEn el método de Adams-Bashforth se busca obtener un método que resulte explícito y por lo tanto se propone $\\beta_s = 0$, es decir\n\\begin{equation*}\n y^{n+s} - y^{n+s-1} = k\\sum_{j=0}^{s-1} \\beta^j f^{n+j} \\tag{Adams-Bashforth}\n\\end{equation*}\nDe esta forma solo queda determinar los coeficientes $\\beta^{n}, \\dots, \\beta^{n+s-1}$ y con ello tendremos ya una fórmula que permite determinar $y^{n+s}$ si conocemos $y^{n+s-1}$ y $f^{n}, \\dots, f^{n+s-1}$. Para ello, naturalmente, buscaremos un método consistente y maximizar el orden de aproximación a $y^{n+s}$. Para esto consideremos $Y$ una solución exacta a la EDO en cuestión, reemplazando en la última ecuación tenemos\n\\begin{gather*}\n \\left[ Y + \\dot{Y}k + \\ddot{Y}\\frac{k^2}{2} + \\dots \\right]_{t^{n+s-1}} - Y^{n+s-1} + \\delta Y = k \\left\\{ \\beta^{s-1} f^{n+s-1} + \\beta^{s-2} \\left[ f - \\dot{f} k + \\ddot{f} \\frac{k^2}{2} + \\dots \\right]_{t^{n+s-1}} + \\\\\n + \\ldots + \\beta^0 \\left[ f - \\dot{f} (s-1)k + \\ddot{f} \\frac{(s-1)^2 k^2}{2} + \\dots \\right]_{t^{n+s-1}} \\right\\}\n\\end{gather*}\ndonde reemplazamos $Y^{n+s}$ por su expansión de Taylor alrededor de $Y^{n+s-1}$, $f^{n+s-j}$ por las correspondientes expansiones alrededor de $f^{n+s-1}$, y $\\delta Y$ es el error de truncamiento. Regrupando obtenemos\n\\begin{equation}\n \\delta Y = k \\dot Y^{n+s-1} \\left[ \\beta^{s-1} + \\beta^{s-2} + \\ldots + \\beta^0 - 1\\right] + \\\\\n + k^2 \\ddot Y \\left[ - \\beta^{s-2} - \\ldots - (s-1) \\beta^0 - \\frac{1}{2} \\right] + \\dots, \\tag{Error de truncamiento}\n\\end{equation}\ndonde usamos $f^j = \\dot Y^j$, $\\dot f^j = \\ddot Y^j$ y así sucesivamente.\n\nVemos que para que haya consistencia, debemos pedir $\\sum_j \\beta^j = 1$, este resultado es general y aplica a todos los métodos multipaso lineales. Los restantes $s$ coeficientes se obtienen intentando cancelar la mayor cantidad de potencias de $k$, de forma de conseguir un método con el mejor orden de aproximación posible para la cantidad de pasos en consideración.\n\n##### **Deducción de coeficientes para un método de 3 pasos**\n\nPara ver un ejemplo de esto, intentemos deducir el método de Adams-Bashforth que utiliza 3 pasos ($s=3$). Es decir, debemos determinar $\\beta^0, \\beta^1, \\beta^2$ ($\\beta^3 = 0$ por ser explícito, i.e. un método de Adams-Bashforth). Para ello, escribimos el caso partícular de la ecuación anterior\n\\begin{gather*}\n \\delta Y = k \\dot Y \\left[ \\beta^2 + \\beta^1 + \\beta^0 - 1\\right] + k^2 \\ddot Y \\left[ -\\beta^1 - 2\\beta^0 - \\frac{1}{2} \\right] + \\\\\n + k^3 \\dddot Y \\left[ \\frac{\\beta^1}{2} + \\frac{2^2}{2} \\beta^0 - \\frac{1}{6} \\right] + \\mathcal{O}(k^4),\n\\end{gather*}\ny pidiendo que se anulen la mayor cantidad de órdenes dominantes posibles (i.e., lo que acompaña a $k$, $k^2$, $k^3$) tenemos\n\\begin{equation*}\n\\begin{pmatrix}\n 1 & 1 & 1 \\\\\n -2 & -1 & 0 \\\\\n 2 & \\frac{1}{2} & 0\n\\end{pmatrix}\n\\begin{pmatrix}\n \\beta^0\\\\\n \\beta^1\\\\\n \\beta^2\n\\end{pmatrix}\n= \\begin{pmatrix}\n 1 \\\\\n \\frac{1}{2} \\\\\n \\frac{1}{6} \n\\end{pmatrix},\n\\end{equation*}\nque tiene como solución\n\\begin{equation*}\n \\beta^0 = \\frac{5}{12}, \\qquad \\beta^1 = - \\frac{16}{12}, \\qquad \\beta^2 = \\frac{23}{12},\n\\end{equation*}\nobteniendo un método donde $\\delta F = \\mathcal{O}(k^4)$, o sea, un método de orden $3$ (recuerden que el orden global es un orden de magnitud menor que el error al cabo de un paso). En general, un método de Adams-Bashforth de $s$ pasos, posee un orden (global) $s$.\n\nEn una notación más operativa, podemos escribir el resultado hallado como\n\\begin{equation}\n y^{n+1} = y^n + \\frac{k}{12} \\left( 23 f^n - 16 f^{n-1} + 5 f^{n-2} \\right).\n\\end{equation}\n\nVeamos en acción el método que acabamos de derivar. Para eso consideramos el problema de valor inicial\n\\begin{equation*}\n \\dot y (t) = -y(t) + \\mathrm{sen}(t), \\qquad y(0)=1/2,\n\\end{equation*}\npara $0 \\le t \\le 10$, que tiene como solución analítica $y(t) = e^{-t} + [\\mathrm{sen}(t) - \\cos(t)]/2$. Nos valdremos de esta solución analítica para resolver el problema de la inicialización. Esta estrategia no será posible cuando desconozcamos la solución analítica, debiendo recurrir a inicializar la integración con otros métodos, como mencionamos anteriormente.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndt = 2.5e-1 # Paso temporal\ny0 = 1/2 # Condición inicial\ntf = 10 # Tiempo final de integración\npasos = int(round(tf/dt)) # Cantidad de pasos\n\ny = np.zeros( pasos+1 ) # Variable para ir guardando la integración\n\n# Agrego los tres primeros pasos\ny[0] = y0\ny[1] = np.exp(-dt) + (np.sin(dt) - np.cos(dt) )/2\ny[2] = np.exp(-2*dt) + (np.sin(2*dt)-np.cos(2*dt))/2\n\n# Integro usando AB3\nfor n in range(2, pasos):\n tn = n*dt # t^n\n tn1 = (n-1)*dt # t^{n-1}\n tn2 = (n-2)*dt # t^{n-2}\n\n fn = -y[n] + np.sin(tn) # f^n\n fn1 = -y[n-1] + np.sin(tn1) # f^{n-1}\n fn2 = -y[n-2] + np.sin(tn2) # f^{n-2}\n\n y[n+1] = y[n] + (23*fn - 16*fn1 + 5*fn2)*dt/12 # Integración explícita\n\n# Grafico\nt = np.arange(0, y.size)*dt\nfig, ax = plt.subplots(1, 1, figsize=(8,4), constrained_layout=True)\nax.plot(t, y, label=r\"AB3 ($k=2,5 \\times 10^{-1})$\", c=\"C1\", lw=4)\nax.plot(t, np.exp(-t) + (np.sin(t)-np.cos(t))/2, \"--k\", label=\"Solución exacta\")\nax.legend()\nax.set_title(r\"Integración de $\\dot{y} = -y + \\mathrm{sen(t)}$, $y(0)=1/2$\")\nax.set_xlabel(\"$t$\")\nax.set_ylabel(\"$y$\");\n```\n\n##### **Resumen de métodos de Adams-Bashforth**\n\nIncluimos a continuación una tabla con los coeficientes que acompañan a cada evaluación de $f$ para los métodos de Adams-Bashforth hasta orden $4$.\n\n| $\\mathrm{Pasos}$ | $\\mathrm{Orden}$ | $f^n$ | $f^{n-1}$ | $f^{n-2}$ | $f^{n-3}$ |\n|------------------|------------------|----------------|----------------|----------------|---------------|\n| $1$ | $1$ | $1$ | $0$ | $0$ | $0$ |\n| $2$ | $2$ |$\\frac{3}{2}$ | $-\\frac{1}{2}$ | $0$ | $0$ |\n| $3$ | $3$ |$\\frac{23}{12}$ |$-\\frac{16}{12}$| $\\frac{5}{12}$ | $0$ |\n| $4$ | $4$ |$\\frac{55}{24}$ |$-\\frac{59}{24}$| $\\frac{37}{24}$|$-\\frac{9}{24}$|\n\nNoten que para $s=1$ recuperamos el método de Euler hacia adelante.\n\n#### **Adams-Moulton**\n\nEn los métodos de Adams-Moulton se sigue la misma lógica que la empleada en Adams-Bashforth, pero se relaja la restricción $\\beta^s = 0$, resultando por tanto en un método implícito. La forma de obtener los coeficientes apropiados es completamente análoga, obteniendo\nla siguiente relación para el error de truncamiento\n\\begin{equation}\n \\delta Y = k \\dot Y^{n+s-1} \\left[ \\beta^s + \\beta^{s-1} + \\beta^{s-2} + \\ldots + \\beta^0 - 1\\right] + k^2 \\ddot Y \\left[ \\beta^s - \\beta^{s-2} - \\ldots - (s-1) \\beta^0 - \\frac{1}{2} \\right] + \\dots,\n\\end{equation}\nque naturalmente tiene un grado de libertad mayor a la expresión hallada para Adams-Bashforth, dado por $\\beta^s$.\n\n##### **Deducción de coeficientes para un método de 3 pasos**\n\nDe manera análoga a lo que hicimos para el caso explícito, calculemos los coeficientes para el método implícito (Adams-Moulton) de 3 pasos. Esto implica hallar $\\beta^3$, $\\beta^2$, $\\beta^1$ y $\\beta^0$. Para ello escribamos el error de truncamiento hasta un orden apropiado\n\\begin{gather*}\n \\delta Y = k \\dot Y \\left[ \\beta^3 + \\beta^2 + \\beta^1 + \\beta^0 - 1\\right] + k^2 \\ddot Y \\left[ \\beta^3 -\\beta^1 - 2\\beta^0 - \\frac{1}{2} \\right] + \\\\\n + k^3 \\ddot Y \\left[ \\frac{\\beta^3}{2} + \\frac{\\beta^1}{2} + \\frac{2^2}{2} \\beta^0 - \\frac{1}{6} \\right] + + k^4 \\ddot Y \\left[ \\frac{\\beta^3}{6} - \\frac{\\beta^1}{6} - \\frac{2^3}{6} \\beta^0 - \\frac{1}{24} \\right] + \\mathcal{O}(k^5).\n\\end{gather*}\nPedimos nuevamente que se anulen la mayor cantidad de órdenes dominantes posibles, es decir, lo que acompaña a $k$, $k^2$, $k^3$ y $k^4$. Noten que como tenemos un coeficiente más, podemos anular un término más con respecto a lo planteado para Adams-Bashforth. Tenemos entonces\n\\begin{equation*}\n\\begin{pmatrix}\n 1 & 1 & 1 & 1 \\\\\n -2 & -1 & 0 & 1 \\\\\n 2 & \\frac{1}{2} & 0 & \\frac{1}{2}\\\\\n -\\frac{4}{3} & -\\frac{1}{6} & 0 & \\frac{1}{6}\n\\end{pmatrix}\n\\begin{pmatrix}\n \\beta^0\\\\\n \\beta^1\\\\\n \\beta^2\\\\\n \\beta^3\n\\end{pmatrix}\n= \\begin{pmatrix}\n 1 \\\\\n \\frac{1}{2} \\\\\n \\frac{1}{6} \\\\\n \\frac{1}{24} \\\\\n\\end{pmatrix},\n\\end{equation*}\nque tiene como solución\n\\begin{equation*}\n \\beta^0 = \\frac{1}{24}, \\qquad \\beta^1 = - \\frac{5}{24}, \\qquad \\beta^2 = \\frac{19}{24}, \\qquad \\beta^3 = \\frac{9}{24}\n\\end{equation*}\nobteniendo un método $5$. En general, un método de Adams-Moulton de $s$ pasos, posee un orden (global) $s+1$.\n\nEn una notación más operativa, podemos escribir el resultado hallado como\n\\begin{equation}\n y^{n+1} = y^n + \\frac{k}{24} \\left( 9 f^{n+1} + 19 f^n - 5 f^{n-1} + f^{n-2} \\right),\n\\end{equation}\nque es una expresión implícita para $y^{n+1}$.\n\nAl igual que hicimos antes, consideremos el problema de valores iniciales\n\\begin{equation*}\n \\dot y (t) = -y(t) + \\mathrm{sen}(t), \\qquad \\qquad y(0) = 1/2,\n\\end{equation*}\npara $0 \\le t \\le 10$. Al igual que antes, haremos uso de la solución analítica $y(t) = e^{-t} + \\left[\\mathrm{sen}(t) - \\cos(t) \\right]/2$ para inicializar la integración. Además, dado que esta ecuación es lineal, el hecho de que el método sea implícito no supondrá dificultad, ya que puede realizarse el despeje de la siguiente manera\n\\begin{align*}\n y^{n+1} &= y^n + \\frac{k}{24} \\left[9(-y^{n+1} + \\mathrm{sen}(t^{n+1}) + 19f^n - 5f^{n-1} + f^{n-2} \\right]\\\\\n &= \\left[y^n + \\frac{k}{24} \\left(9\\ \\mathrm{sen}(t^{n+1}) + 19f^n - 5f^{n-1} + f^{n-2} \\right) \\right] \\frac{1}{1 + \\dfrac{9}{24}k}.\n\\end{align*}\n\nEsto no generalizará a problemas no lineales, donde habrá que usar algún esquema iterativo para hallar $y^{n+1}$.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\ndt = 2.5e-1 # Paso temporal\ny0 = 1/2 # Condición inicial\ntf = 10 # Tiempo final de integración\npasos = int(round(tf/dt)) # Cantidad de pasos\n\ny = np.zeros( pasos+1 ) # Variable para ir guardando la integración\n\n# Condición inicial y primeras iteraciones (las saco de la solución analítica)\ny[0] = y0\ny[1] = np.exp(-dt) + (np.sin(dt) - np.cos(dt) )/2\ny[2] = np.exp(-2*dt) + (np.sin(2*dt)-np.cos(2*dt))/2\n\n# Integro usando AM4\nfor n in range(2, pasos):\n ts = (n+1)*dt # t^{n+1} (tiempo siguiente)\n tn = n*dt # t^n\n tn1 = (n-1)*dt # t^{n-1}\n tn2 = (n-2)*dt # t^{n-2}\n\n fn = -y[n] + np.sin(tn) # f^n\n fn1 = -y[n-1] + np.sin(tn1) # f^{n-1}\n fn2 = -y[n-2] + np.sin(tn2) # f^{n-2}\n\n y[n+1] = (y[n] + (9*np.sin(ts) + 19*fn - 5*fn1 + fn2)*dt/24)/(1+9/24*dt)\n\n# Grafico\nt = np.arange(0, y.size)*dt\nfig, ax = plt.subplots(1, 1, figsize=(8,4), constrained_layout=True)\nax.plot(t, y, label=r\"AM3 ($k=2,5 \\times 10^{-1})$\", c=\"C1\", lw=4)\nax.plot(t, np.exp(-t) + (np.sin(t)-np.cos(t))/2, \"--k\", label=\"Solución exacta\")\nax.legend()\nax.set_title(r\"Integración de $\\dot{y} = -y + \\mathrm{sen(t)}$, $y(0)=1/2$\")\nax.set_xlabel(\"$t$\")\nax.set_ylabel(\"$y$\");\n```\n\n##### **Resumen de métodos de Adams-Moulton**\n\n| $\\mathrm{Pasos}$ | $\\mathrm{Orden}$ | $f^{n+1}$ | $f^n$ | $f^{n-1}$ | $f^{n-2}$ | $f^{n-3}$ |\n|------------------|------------------|-----------------|-----------------|------------------|-----------------|-----------------|\n| $1$ | $1$ | $1$ | $0$ | $0$ | $0$ | $0$ |\n| $1$ | $2$ |$\\frac{1}{2}$ |$\\frac{1}{2}$ | $0$ | $0$ | $0$ |\n| $2$ | $3$ |$\\frac{5}{12}$ |$\\frac{8}{12}$ |$-\\frac{1}{12}$ | $0$ | $0$ |\n| $3$ | $4$ |$\\frac{9}{24}$ |$\\frac{19}{24}$ |$-\\frac{5}{24}$ |$\\frac{1}{24}$ | $0$ |\n| $4$ | $5$ |$\\frac{251}{720}$|$\\frac{646}{720}$|$-\\frac{264}{720}$|$\\frac{106}{720}$|$-\\frac{19}{720}$|\n\nVemos que el caso de $1$ paso resulta degenerado, teniendo dos esquemas posibles. El de orden $1$ no es ni más ni ménos que el método de Euler atrasado, mientras que el esquema de segundo orden se conoce como regla trapezoidal.\n\n#### **Otros métodos multipaso lineales**\n\nSin demostraciones de por medio, podemos mencionar otras familias populares de métodos multipaso lineales. Una opción por ejemplo es buscar operadores temporales centrados, que resulten de la forma \n\\begin{equation*}\ny^{n+s}-y^{n+s-2} = \\sum_{j=0}^s \\beta^j f^{n+j}.\n\\end{equation*}\nLos métodos explícitos ($\\beta^s=0$) asociados a esta elección reciben el nombre de _métodos de Nyström_, mientras que a aquellos implícitos se los conoce como métodos de _Milne-Simpson_, y tienen orden $s$ y $s+1$, respectivamente. Un método de Nyström que vieron en las clases teóricas es aquel conocido como _**Salto de rana**_ (o _leapfrog_ en inglés), dado por\n\\begin{equation*}\n y^{n+1} = y^{n-1} + 2k f^n,\n\\end{equation*}\nque como vieron en las clases teóricas presenta un modo computacional (es decir, un modo _no-físico_).\n\nAdicionalmente, y de manera opuesta a lo que proponen los métodos de Adams, pueden buscarse métodos con $\\beta^0 = \\beta^1 = \\ldots = \\beta^{s-1} = 0$, donde se ajusta $\\beta^s$ y $\\boldsymbol \\alpha$. Estos esquemas reciben el nombre de **_fórmulas de diferenciación hacia atrás_** (o _backward differentiation formulas_ — BDF en inglés—).\n\n### **Métodos predictores-correctores**\n\nComo mencionamos anteriormente, los métodos predictores-correctores consisten en usar dos integradores temporales y combinarlos. La técnica más común es la que combina un método explícito con uno implícito, de la siguiente manera\n\n1. **Paso predictor ($P$) **: Usamos un método explícito para obtener una estimación de $y^{n+1}$, que llamamos $y^{*n+1}$ por ejemplo, utilizando Euler adelantado tendremos:\n\\begin{equation*}\n y^{*n+1} = y^n + kf^n.\n\\end{equation*}\n\n2. **Paso evaluador ($E$) **: A partir de la estimación para $y^{n+1}$ obtenida en el paso anterior, calculamos $f(t^{n+1}, y^{*n+1})$, es decir, $f^{*n+1}$.\n\n3. ** Paso corrector ($C$) **: Llamando $f^{*n+1}$ a $f(t^{n+1}, y^{*n+1})$, resolvemos para un esquema implícito. Utilizando ahora como ejemplo Euler atrasado, se obtiene:\n\\begin{equation}\n y^{n+1} = y^n + kf^{*n+1} = y^n + kf(t^{n+1}, y^n + kf^n). \\tag{Matsuno}\n\\end{equation}\nEl método que acabamos de hallar es conocido como **_método de Matsuno_** y es $\\mathcal{O}(k)$. Análogamente podríamos haber utilizado el esquema trapezoidal (Adams-Moulton de 2do orden) en lugar de Euler atrasado y tendríamos\n\\begin{equation}\n y^{n+1} = y^n + \\frac{k}{2} \\left( f^{*n+1} + f^n \\right) = y^n + \\frac{k}{2}\\left[f(t^{n+1}, y^n + kf^n) + f(t^n, y^n) \\right], \\tag{Heun}\n\\end{equation}\nconocido como **_método de Heun_**, cuyo orden global es $\\mathcal{O}(k^2)$.\n\nNoten que en ambos casos acabamos con métodos explícitos, derivados de la combinación de uno explícito y uno implícito.\n\nVale mencionar que es posible realizar este proceso de manera iterativa, utilizando las ecuaciones de $(\\mathrm{Matsuno})$ y $(\\mathrm{Heun})$ como nuevos candidatos $y^{*n+1}$, obteniendo un nuevo valor para $f^{*n+1}$ y volviendo a aplicar el método respectivo para obtener $y^{n+1}$. Si realizamos la operación de corrección $c$ veces, suele notarse al método resultante como $P(EC)^c$.\n\nSi bien los métodos predictores-correctores pueden estudiarse más formalmente, no lo haremos en el curso. Solo mencionaremos que otra combinación común para generar métodos predictores-correctores es la conjunción de métodos de Adams-Bashforth (predictor) y Adams-Moulton (corrector), que reciben el nombre de _métodos Adams-Bashforth-Moulton_.\n\n\n### **Métodos de Runge-Kutta**\n\nA diferencia de los métodos multipaso, que utilizan valores de $y$ y $f$ calculados en pasos anteriores (o para el paso posterior si son implícitos), la idea de los métodos de Runge-Kutta es utilizar múltiples evaluaciones de $f$ entre $t^n$ y $t^{n+1}$ (denominadas _etapas_) para generar una aproximación de mayor orden.\n\nA priori, esto podría parecer ineficiente ya que en los métodos multipaso usamos información ya conocida, mientras que en Runge-Kutta estaremos utilizando nuevas evaluaciones que emplearemos solo para el paso en cuestión. Sin embargo, los métodos de Runge-Kutta precisan menos almacenamiento en memoria. Además presentan distintas características de estabilidad con respecto a los métodos multipaso, por lo que pueden ser más apropiados para algunas EDOs.\n\nLos métodos de Runge-Kutta se clasifican de acuerdo a la cantidad de etapas (así como los multipaso a la cantidad de pasos utilizados). Por ejemplo, para un método de dos etapas tendremos\n\\begin{equation*}\n y^{n+1} = y^{n} + k \\left( \\alpha_1 f^n_1 + \\alpha_2 f^n_2 \\right),\n\\end{equation*}\ndonde $f^n_1=f(t^n_1, y^n_1)$ y $f^n_2=f(t^n_2, y^n_2)$ son evaluaciones de $f$ entre $t^n$ y $t^{n+1}$, es decir, $t^n \\le t^n_1 \\le t^n_2 \\le t^{n+1}$. La misma idea aplica para métodos con más etapas. _**Vale resaltar que veremos solo los métodos de Runge-Kutta explícitos ya que son los más empleados**_.\n\nEn general, y a diferencia de los métodos multipaso, en el caso de Runge-Kutta no alcanza con definir una cantidad de etapas $s$ y buscar maximizar el orden de aproximación para obtener un método único. Sin embargo, si nos restringimos a métodos cuyas evaluaciones de $f$ están equiespaciadas (aunque en algunos casos repetidas), obtenemos los siguientes esquemas:\n\n\n* _**Segundo orden**_:\n\n\\begin{align}\n y^{n+1} &= y^n + R_2, \\tag{Midpoint} \\\\\n R_1 &= kf\\left( t^n, y^n \\right), \\\\\n R_2 &= kf\\left( t^n + \\frac{k}{2}, y^n + \\frac{R_1}{2}\\right)\n\\end{align}\n\n .\n\n\n```python\nfrom IPython.core.display import HTML\n\n\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "f1937edaf0e3896fda264043258d28da9eca6a6c", "size": 347818, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Chapter1.ipynb", "max_stars_repo_name": "tomkimpson/BayesianMethodsForHackers", "max_stars_repo_head_hexsha": "597f2f24810e0376835ccbe4a13f7e133204f2da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Chapter1.ipynb", "max_issues_repo_name": "tomkimpson/BayesianMethodsForHackers", "max_issues_repo_head_hexsha": "597f2f24810e0376835ccbe4a13f7e133204f2da", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Chapter1.ipynb", "max_forks_repo_name": "tomkimpson/BayesianMethodsForHackers", "max_forks_repo_head_hexsha": "597f2f24810e0376835ccbe4a13f7e133204f2da", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2017-01-24T02:59:37.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-03T06:25:03.000Z", "avg_line_length": 309.9982174688, "max_line_length": 90684, "alphanum_fraction": 0.8970898573, "converted": true, "num_tokens": 11653, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4263215925474903, "lm_q2_score": 0.2814055953761018, "lm_q1q2_score": 0.11996928157251441}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ntag = HTML('''\nPromijeni vidljivost ovdje .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n```\n\n\n\nPromijeni vidljivost ovdje .\n\n\n\n```python\n%matplotlib notebook\n\nimport numpy as np\nimport control as control\nimport matplotlib.pyplot as plt\nimport ipywidgets as widgets\nimport sympy as sym\n# from IPython.display import Markdown # For displaying Markdown and LaTeX code\n\nsym.init_printing()\ncontinuous_update=False\n```\n\n## Pogreška stacionarnog stanja\n\nS obzirom na ulaznu prijenosnu funkciju $I(s)$ i prijenosnu funkciju sustava otvorene petlje $G(s)$, pogreška u stacionarnom stanju $e(\\infty)$ sustava zatvorene petlje može se, u slučaju jedinstvene povratne veze (engl. unity feedback), odrediti kao:\n\n\\begin{equation}\n e(\\infty)=\\lim_{s\\to0}\\frac{sI(s)}{1+G(s)}.\n\\end{equation}\n\nu slučaju jedinične step funkcije kao ulaza $I(s)=\\frac{1}{s}$ dobiva se:\n\n\\begin{equation}\n e_{step}(\\infty)=\\frac{1}{1+\\lim_{s\\to0}G(s)},\n\\end{equation}\n\nu slučaju rampa funkcije $I(s)=\\frac{1}{s^2}$:\n\n\\begin{equation}\n e_{ramp}(\\infty)=\\frac{1}{\\lim_{s\\to0}sG(s)},\n\\end{equation}\n\na u slučaju parabolične funkcije $I(s)=\\frac{1}{s^3}$:\n\n\\begin{equation}\n e_{parabolic}(\\infty)=\\frac{1}{\\lim_{s\\to0}s^2G(s)}\n\\end{equation}\n\n\n### Sustavi bez integracije\n\nPrimjer prijenosne funckije $G(s)$ sustava bez integracije može se definirati kao:\n\n\\begin{equation}\n G(s) = \\frac{K}{as^2 + bs + c}\n\\end{equation}\n\nPogreška stacionarnog stanja u slučaju sustava bez integracije u unaprijednoj stazi je beskonačna za ulaznu funkciju rampe i ulaznu paraboličnu funkciju.\n\n### Sustavi s jednom integracijom\n\nPrimjer prijenosne funckije $G(s)$ sustava s jednom integracijom može se definirati kao:\n\n\\begin{equation}\n G(s) = \\frac{K(as^2 + bs + c)}{s(ds^2 + es + fc)}\n\\end{equation}\n\nPogreška stacionarnog stanja u slučaju sustava s jednom integracijom u unaprijednoj stazi je beskonačna za ulaznu paraboličnu funkciju.\n\n---\n\n### Kako koristiti ovaj interaktivni primjer?\n\n- Izaberite između sustava bez integracije i sustava s jednom integracijom.\n- Pomičite klizače za promjenu vrijednosti $a$, $b$, $c$ (koeficijenata prijenosne funkcije) i $K$ (pojačanja).\n\n\n```python\nstyle = {'description_width': 'initial'}\n\nlayout1 = widgets.Layout(width='auto', height='auto') #set width and height\n\nsystemSelect = widgets.ToggleButtons(\n options=[('bez integracije', 0), ('jedna integracija', 1)],\n description='Odaberi sustav: ',style=style)\nfunctionSelect = widgets.ToggleButtons(\n options=[('jedinična step funkcija', 0), ('rampa funkcija', 1), ('parabolična funkcija', 2)],\n description='Odaberi ulaznu funkciju: ',style=style)\n\nfig=plt.figure(num='Pogreška stacionarnog stanja')\nfig.set_size_inches((9.8,3))\nfig.set_tight_layout(True)\nf1 = fig.add_subplot(1, 1, 1)\n\nf1.grid(which='both', axis='both', color='lightgray')\n\nf1.set_ylabel('ulaz, izlaz')\nf1.set_xlabel('$t$ [s]')\n\ninputf, = f1.plot([],[])\nresponsef, = f1.plot([],[])\nerrorf, = f1.plot([],[])\n\nann1=f1.annotate(\"\", xy=([0], [0]), xytext=([0], [0]))\nann2=f1.annotate(\"\", xy=([0], [0]), xytext=([0], [0]))\n\ndisplay(systemSelect)\ndisplay(functionSelect)\n\ndef create_draw_functions(K,a,b,c,index_system,index_input):\n \n num_of_samples = 1000\n total_time = 150\n t = np.linspace(0, total_time, num_of_samples) # time for which response is calculated (start, stop, step)\n \n if index_system == 0:\n \n Wsys = control.tf([K], [a, b, c])\n ess, G_s, s, n = sym.symbols('e_{step}(\\infty), G(s), s, n')\n sys1 = control.feedback(Wsys)\n \n elif index_system == 1:\n \n Wsys = control.tf([K,K,K*a], [1, b, c, 0])\n ess, G_s, s, n = sym.symbols('e_{step}(\\infty), G(s), s, n')\n sys1 = control.feedback(Wsys) \n \n global inputf, responsef, ann1, ann2\n \n if index_input==0:\n infunction = np.ones(len(t))\n infunction[0]=0\n tout, yout = control.step_response(sys1,t)\n s=sym.Symbol('s')\n if index_system == 0:\n limit_val = sym.limit((K/(a*s**2+b*s+c)),s,0)\n elif index_system == 1:\n limit_val = sym.limit((K*s*s+K*s+K*a)/(s*s*s+b*s*s+c*s),s,0)\n e_inf=1/(1+limit_val)\n \n elif index_input==1:\n infunction=t;\n tout, yout, xx = control.forced_response(sys1, t, infunction)\n if index_system == 0:\n limit_val = sym.limit(s*(K/(a*s**2+b*s+c)),s,0) \n elif index_system == 1:\n limit_val = sym.limit(s*((K*s*s+K*s+K*a)/(s*s*s+b*s*s+c*s)),s,0)\n e_inf=1/limit_val\n \n elif index_input==2:\n infunction=t*t\n tout, yout, xx = control.forced_response(sys1, t, infunction)\n if index_system == 0:\n limit_val = sym.limit(s*s*(K/(a*s**2+b*s+c)),s,0)\n elif index_system == 1:\n limit_val = sym.limit(s*s*((K*s*s+K*s+K*a)/(s*s*s+b*s*s+c*s)),s,0)\n e_inf=1/limit_val\n \n ann1.remove()\n ann2.remove() \n \n if type(e_inf) == sym.numbers.ComplexInfinity:\n print('Pogreška stacionarnog stanja je beskonačna.')\n elif e_inf==0:\n print('Pogreška stacionarnog stanja je nula.')\n else:\n print('Pogreška stacionarnog stanja je jednaka %f.'% (e_inf,)) \n \n# if type(e_inf) == sym.numbers.ComplexInfinity:\n# display(Markdown('Steady-state error is infinite.'))\n# elif e_inf==0:\n# display(Markdown('Steady-state error is zero.'))\n# else:\n# display(Markdown('Steady-state error is equal to %f.'%(e_inf,)))\n\n \n if type(e_inf) != sym.numbers.ComplexInfinity and e_inf>0: \n ann1=plt.annotate(\"\", xy=(tout[-60],infunction[-60]), xytext=(tout[-60],yout[-60]), arrowprops=dict(arrowstyle=\"|-|\", connectionstyle=\"arc3\"))\n ann2=plt.annotate(\"$e(\\infty)$\", xy=(145, 1.), xytext=(145, (yout[-60]+(infunction[-60]-yout[-60])/2)))\n elif type(e_inf) == sym.numbers.ComplexInfinity:\n ann1=plt.annotate(\"\", xy=(0,0), xytext=(0,0), arrowprops=dict(arrowstyle=\"|-|\", connectionstyle=\"arc3\"))\n ann2=plt.annotate(\"\", xy=(134, 1.), xytext=(134, (1 - infunction[-10])/2 + infunction[-10]))\n elif type(e_inf) != sym.numbers.ComplexInfinity and e_inf==0: \n ann1=plt.annotate(\"\", xy=(0,0), xytext=(0,0), arrowprops=dict(arrowstyle=\"|-|\", connectionstyle=\"arc3\"))\n ann2=plt.annotate(\"\", xy=(134, 1.), xytext=(134, (1 - yout[-10])/2 + yout[-10]))\n \n f1.lines.remove(inputf)\n f1.lines.remove(responsef)\n \n inputf, = f1.plot(t,infunction,label='ulaz',color='C0')\n responsef, = f1.plot(tout,yout,label='izlaz',color='C1')\n \n f1.relim()\n f1.autoscale_view()\n \n f1.legend()\n\nK_slider=widgets.IntSlider(min=1,max=8,step=1,value=1,description='$K$',continuous_update=False)\na_slider=widgets.IntSlider(min=0,max=8,step=1,value=1,description='$a$',continuous_update=False)\nb_slider=widgets.IntSlider(min=0,max=8,step=1,value=1,description='$b$',continuous_update=False)\nc_slider=widgets.IntSlider(min=1,max=8,step=1,value=1,description='$c$',continuous_update=False)\n\ninput_data=widgets.interactive_output(create_draw_functions,\n {'K':K_slider,'a':a_slider,'b':b_slider,'c':c_slider,\n 'index_system':systemSelect,'index_input':functionSelect})\n\ndef update_sliders(index):\n global K_slider, a_slider, b_slider, c_slider\n \n Kval=[1, 1, 1]\n aval=[1, 1, 1]\n bval=[2, 2, 2]\n cval=[6, 6, 6]\n \n K_slider.value=Kval[index]\n a_slider.value=aval[index]\n b_slider.value=bval[index]\n c_slider.value=cval[index]\n \ninput_data2=widgets.interactive_output(update_sliders,\n {'index':functionSelect})\n\n\ndisplay(K_slider,a_slider,b_slider,c_slider,input_data)\n```\n\n\n \n\n\n\n\n\n\n\n ToggleButtons(description='Odaberi sustav: ', options=(('bez integracije', 0), ('jedna integracija', 1)), styl…\n\n\n\n ToggleButtons(description='Odaberi ulaznu funkciju: ', options=(('jedinična step funkcija', 0), ('rampa funkci…\n\n\n\n IntSlider(value=1, continuous_update=False, description='$K$', max=8, min=1)\n\n\n\n IntSlider(value=1, continuous_update=False, description='$a$', max=8)\n\n\n\n IntSlider(value=2, continuous_update=False, description='$b$', max=8)\n\n\n\n IntSlider(value=6, continuous_update=False, description='$c$', max=8, min=1)\n\n\n\n Output()\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "6c22d7fa4ae3f8ecdc34452aa94948a56e712404", "size": 83421, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_hr/examples/02/TD-17-Pogreska_stacionarnog_stanja.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-17-Pogreska_stacionarnog_stanja-checkpoint.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-17-Pogreska_stacionarnog_stanja-checkpoint.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 68.3778688525, "max_line_length": 33843, "alphanum_fraction": 0.6764244015, "converted": true, "num_tokens": 2758, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4493926344647597, "lm_q2_score": 0.2658804614657029, "lm_q1q2_score": 0.11948472103077824}}
{"text": "```python\nimport holoviews as hv\nhv.extension('bokeh')\nhv.opts.defaults(hv.opts.Curve(width=500), \n hv.opts.Points(width=500), \n hv.opts.Image(width=500, colorbar=True, cmap='Viridis'))\n```\n\n\n```python\nimport numpy as np\nimport scipy.signal\nimport scipy.linalg\n```\n\n# Estimadores adaptivos parte II\n\nEn esta lección veremos algunos estimadores adaptivos que extienden el filtro LMS que revisamos en la lección anterior\n\n## Algoritmo de Mínimos Cuadrados Recursivos \n\n\nEl algoritmo LMS minimiza el error instantaneo y es simple y eficiente. Pero en algunos casos su convergencia es demasiado lenta\n\n:::{tip}\n\nPodemos obtener un filtro adaptivo que converge más rápido si utilizamos el error histórico en lugar del error instantaneo\n\n:::\n\nSigamos considerando un filtro tipo FIR con $L+1$ pesos que se actualizan de en cada época $n$\n\n$$\ny_n = \\sum_{k=0}^L w_{n, k} u_{n-k}\n$$\n\nEl algoritmo RLS (*Recursive Least Squares*) es un método online que minimiza el error histórico, es decir la suma de errores desde la muestra inicial hasta la actual\n\n$$\n\\begin{align}\nJ^H_n(\\textbf{w}) &= \\sum_{i=L}^n \\beta^{n-i} |e_i|^2 \\nonumber \\\\\n&= \\sum_{i=L}^n \\beta^{n-i} (d_i - \\sum_{k=0}^{L} w_{i, k} u_{i-k} )^2, \\nonumber\n\\end{align}\n$$\n\ndonde $n$ es el índice del instante actual y $\\beta \\in [0, 1]$ es el \"factor de olvido\", que usualmente es un valor cercano pero ligeramente menor que $1$.\n\nAdicionalmente se agrega un regularizador a los pesos\n\n$$\nJ^w_n = \\lambda \\| \\textbf{w}_{n} \\|^2 = \\lambda \\sum_{k=1} w_{n, k}^2\n$$\n\nPara evitar divergencias en el proceso de entrenamiento\n\n:::{important}\n\nLa función de costo total del filtro RLS es la suma de error histórico y el regularizador\n\n:::\n\n### Solución exacta del filtro RLS\n\nSi derivamos la función de costo e igualamos a cero obtenemos la siguiente regla\n\n$$\n\\begin{align}\n\\textbf{w}_n &= (U_n^T \\pmb{\\beta} U_n + \\lambda I)^{-1} U_n^T \\pmb{\\beta} \\textbf{d}_n \\nonumber \\\\\n&= \\Phi_n^{-1} \\theta_n \\nonumber\n\\end{align}\n$$\n\ndonde reconocemos los siguientes términos\n\n- Matriz de correlación ponderada y regularizada: $\\Phi_n = U_n^T \\pmb{\\beta} U_n + \\lambda I$\n- Vector de correalación cruzada ponderada: $\\theta_n = U_n^T \\pmb{\\beta} \\textbf{d}_n$\n\nque se definen en función\n\n$$\n\\textbf{d}_n = \\begin{pmatrix} d_n \\\\ d_{n-1} \\\\ \\vdots \\\\ d_{L+1} \\end{pmatrix} \\quad\n\\textbf{u}_n = \\begin{pmatrix} u_n \\\\ u_{n-1} \\\\ \\vdots \\\\ u_{n-(L+1)} \\end{pmatrix} \\quad\n\\pmb{\\beta} = I \\begin{pmatrix} \\beta \\\\ \\beta^{1} \\\\ \\beta^{2} \\vdots \\\\ \\beta^{n-L-1} \\end{pmatrix}\n\\quad \nU_n = \\begin{pmatrix}\n\\textbf{u}_n^T \\\\ \\textbf{u}_{n-1}^T \\\\ \\vdots \\\\ \\textbf{u}_{L+1}^T \\\\\n\\end{pmatrix} \\in \\mathbb{R}^{n - (L+1) \\times L+1}\n$$\n\ndonde $I$ es la matriz identidad\n\n:::{note}\n\nEsta solución es similar a la del filtro de Wiener. Es difícil actualizarla a medida que llegan nuevas observaciones y además es muy costosa debido al cálculo del inverso de la matriz de correlación\n\n:::\n\n### Solución recursiva del filtro RLS\n\nEn lugar de la solución cerrada, es más conveniente actualizar los pesos de forma recursiva. Las condiciones iniciales son \n\n- $\\Phi_0 = \\lambda^{-1} I$\n- $\\theta_0 = 0$\n\ny luego la actualización viene dada por \n\n- $\\Phi_{n} = \\beta \\Phi_{n-1} + \\textbf{u}_n \\textbf{u}_n^T$ \n- $\\theta_{n} = \\beta \\theta_{n-1} + \\textbf{u}_n d_n $ \n- $\\textbf{w}_n = \\Phi_n^{-1} \\theta_n$\n\nPodemos evitar invertir la matriz de correlación si usamos el lema de inversión de matrices \n\n$$\n(A + UCV)^{-1} = A^{-1} - A^{-1} U (C^{-1} + VA^{-1} U)^{-1} V A^{-1}\n$$\n\ncon $A = \\Phi_{n-1}^{-1}$, $C=1$, $U= \\textbf{u}_n$ y $V = \\textbf{u}_n^T$. \n\nDe esta forma podemos actualizar $\\Phi_{n}^{-1}$ directamente sin tener que invertirla, como se muestra a continuación\n\n$$\n\\begin{align}\n\\Phi_{n}^{-1} &= \\left(\\beta \\Phi_{n-1} + \\textbf{u}_n \\textbf{u}_n^T \\right)^{-1} \\nonumber \\\\\n&= \\beta^{-1} \\Phi_{n-1}^{-1} - \\beta^{-2} \\frac{\\Phi_{n-1}^{-1} \\textbf{u}_n \\textbf{u}_n^T \\Phi_{n-1}^{-1} }{1 + \\beta^{-1} \\textbf{u}_n^T \\Phi_{n-1}^{-1} \\textbf{u}_n} \\nonumber \\\\\n&= \\beta^{-1} \\Phi_{n-1}^{-1} - \\beta^{-1} \\textbf{k}_n \\textbf{u}_n^T \\Phi_{n-1}^{-1}, \\nonumber \n\\end{align}\n$$\n\ndonde llamamos **ganancia** al factor\n\n$$\n\\textbf{k}_n = \\frac{\\beta^{-1} \\Phi_{n-1}^{-1} \\textbf{u}_n }{1 + \\beta^{-1} \\textbf{u}_n^T \\Phi_{n-1}^{-1} \\textbf{u}_n}\n$$\n\n\n\nEl último paso es obtener al regla de actualización de pesos\n\n$$\n\\begin{align}\n\\textbf{w}_n &= \\Phi_n^{-1} \\theta_n \\nonumber \\\\\n&= \\Phi_n^{-1} \\left ( \\beta \\theta_{n-1} + \\textbf{u}_n d_n \\right) \\nonumber \\\\\n&= \\left ( \\beta^{-1} \\Phi_{n-1}^{-1} - \\beta^{-1} \\textbf{k}_n \\textbf{u}_n^T \\Phi_{n-1}^{-1} \\right ) \\beta \\theta_{n-1} + \\Phi_n^{-1} \\textbf{u}_n d_n \\nonumber \\\\\n&= \\textbf{w}_{n-1} - \\textbf{k}_n \\textbf{u}_n^T \\textbf{w}_{n-1} + \\Phi_n^{-1} \\textbf{u}_n d_n \\nonumber \\\\\n&= \\textbf{w}_{n-1} + \\textbf{k}_n ( d_n - \\textbf{u}_n^T \\textbf{w}_{n-1} ) \\nonumber \\\\\n&= \\textbf{w}_{n-1} + \\textbf{k}_n e_n \\nonumber \n\\end{align}\n$$\n\ndonde usamos que $\\textbf{w}_{n-1} = \\Phi_{n-1}^{-1} \\theta_{n-1}$ y $\\textbf{k}_n = \\Phi_n^{-1} \\textbf{u}_n$\n\n\n\n\n:::{note} \n\nCon esto tenemos un algoritmo de orden cuadrático en lugar de orden cúbico. Esto sigue siendo mayor que LMS que era de orden lineal pero tiene la ventaja de converger más rapidamente.\n\n:::\n\n### Resumen del algoritmo RLS e implementación en Python\n\n```{prf:algorithm} Algoritmo RLS\n:nonumber:\n\n**Hyper-parámetros:** $L$, $\\lambda$, $\\beta$\n\n1. Inicializar $\\Phi_0^{-1} = \\lambda I$ y $\\textbf{w}_0 = 0$\n2. Para $n \\in [1, \\infty]$\n - Calcular la ganancia\n \n $$\n \\textbf{k}_n = \\frac{\\Phi_{n-1}^{-1} \\textbf{u}_n }{\\beta + \\textbf{u}_n^T \\Phi_{n-1}^{-1} \\textbf{u}_n}\n $$ \n \n - Calcular el error \n \n $$\n e_n = d_n - \\textbf{u}_n^T \\textbf{w}_{n-1} \n $$\n \n - Actualizar el error de pesos \n \n $$\n \\textbf{w}_n = \\textbf{w}_{n-1} + \\textbf{k}_n e_n \n $$ \n \n - Actualizar el inverso de la matriz de correlación \n \n $$\n \\Phi_{n}^{-1} = \\beta^{-1} \\Phi_{n-1}^{-1} - \\beta^{-1} \\textbf{k}_n \\textbf{u}_n^T \\Phi_{n-1}^{-1}\n $$\n\n```\n\n\n\n\n- Hiperparámetro $\\beta$: Define la memoría efectiva del sistema y repercute en la convergencia y estabilidad del filtro. Como punto de partida se sugiere un valor de $\\beta \\approx 0.99$. En general $\\beta \\in [0.9, 1.0)$\n- Hiperparámetro $\\lambda$: Mientras más pequeño sea su valor mayor será la regularización. Se recomienda $\\lambda < 0.01/\\sigma_u^2$ donde $\\sigma_u$ es la desviación estándar de la señal de entrada. En la práctica se pueden calibrar con validación cruzada al igual que $L$\n\n\n```python\nclass Filtro_RLS:\n \n def __init__(self, L, beta=0.99, lamb=1e-2):\n self.L = L\n self.w = np.zeros(shape=(L+1, ))\n self.beta = beta\n self.lamb = lamb\n self.Phi_inv = lamb*np.eye(L+1)\n \n def update(self, un, dn):\n # Cálculo de la ganancia\n pi = np.dot(un.T, self.Phi_inv)\n kn = pi.T/(self.beta + np.inner(pi, un))\n # Actualizar el vector de pesos\n error = dn - np.dot(self.w, un)\n self.w += kn*error\n # Actualizar el inverso de Phi\n self.Phi_inv = (self.Phi_inv - np.outer(kn, pi))*self.beta**-1\n return np.dot(self.w, un)\n```\n\n### Ejemplo: ALE con filtro RLS\n\nVeamos como reacciona el filtro RLS ante cambios bruscos usando el ejemplo de la lección pasada. Comparemos con el filtro NLMS\n\n\n```python\nnp.random.seed(12345)\nFs, f0 = 100, 5\nt = np.arange(0, 3, 1/Fs)\ns = np.sin(2.0*np.pi*t*f0)\ns[t>1] += 5\nu = s + 0.5*np.random.randn(len(t))\n\nclass Filtro_NLMS:\n \n def __init__(self, L, mu, delta=1e-6):\n self.L = L\n self.w = np.zeros(shape=(L+1, ))\n self.mu = mu\n self.delta = delta\n \n def update(self, un, dn):\n unorm = np.dot(un, un) + self.delta\n error = dn - np.dot(self.w, un)\n self.w += 2*self.mu*error*(un/unorm)\n return np.dot(self.w, un)\n```\n\n\n```python\nL = 20\nlms = Filtro_NLMS(L, 0.02)\nrls = Filtro_RLS(L, 0.99, 1e-2)\n\nu_pred = np.zeros(shape=(len(u), 2))\nfor k in range(L+1, len(u)):\n u_pred[k, 0] = lms.update(u[k-L-1:k][::-1], u[k])\n u_pred[k, 1] = rls.update(u[k-L-1:k][::-1], u[k])\n```\n\n\n```python\ns1 = hv.Curve((t, s), 'Tiempo', 'Señal', label='Limpia')\ns2 = hv.Scatter((t, u), 'Tiempo', 'Señal', label='Contaminada')\ns3 = hv.Curve((t, u_pred[:, 0]), 'Tiempo', 'Señal', label='Filtrada (LMS)')\ns4 = hv.Curve((t, u_pred[:, 1]), 'Tiempo', 'Señal', label='Filtrada (RLS)')\nhv.Overlay([s1, s2, s3, s4]).opts(hv.opts.Overlay(legend_position='top'), \n hv.opts.Curve(ylim=(-5, 10), height=350))\n```\n\n:::{note} \n\nRLS es capaz de seguir los cambios de la señal en menos tiempo que el filtro LMS\n\n:::\n\n## Perceptrón \n\nEl perceptrón es un filtro adaptivo desarrollado por [Frank Rosemblatt en 1962](https://en.wikipedia.org/wiki/Frank_Rosenblatt) con el objetivo de hacer **clasificación supervisada de patrones**\n\nAsumiremos que\n\n- La respuesta deseada tiene dos categorías: $d_n \\in \\{-1, +1\\}$. El perceptrón resuelve un problema de **clasificación binario**\n- La entrada es continua y de $L$ dimensiones: $u_n \\in \\mathbb{R}^L$\n- Se tienen $N$ tuplas $(u_n, d_n)$ para entrenar el filtro\n\nEl filtro tiene arquitectura FIR con $L+1$ coeficientes pero se agrega una función no lineal $\\phi(\\cdot)$ en la salida del filtro\n\n$$\n\\begin{align}\ny_n &= \\phi \\left(b + \\sum_{k=1}^{M} w_k u_{nk} \\right) \\nonumber \\\\\n&= \\phi \\left(b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle \\right), \\nonumber \n\\end{align}\n$$\n\nLos coeficientes del filtro son el escalar $b$ y el vector $\\textbf{w}$. \n\n:::{note}\n\nEste filtro corresponde al modelo matemático de una neurona de [McCulloch y Pitts](https://link.springer.com/article/10.1007/BF02478259), el antecesor de las actuales redes neuronales profundas\n\n:::\n\nEn la implementación original se utilizó la siguiente función no lineal o función de activación\n\n$$\n\\phi(z) = \\text{sign}(z) = \\begin{cases} +1 & z > 0 \\\\0 & z=0\\\\-1 & z<0 \\end{cases}\n$$\n\nLa siguiente figura esquematiza el modelo y su inspiración biológica\n\n\n\n- Las coeficientes del filtro simulan la importancia o peso de las dendritas\n- La función no lineal simula el axón que dispara un estímulo eléctrico cuando el voltaje supera un umbral\n\n\n\n### Ajuste de la neurona artificial: Algoritmo perceptron\n\nLa neurona ajusta sus parámetros con cada ejemplo que recibe. Asumiendo que tenemos un dataset con $N$ tuplas $(d_i, u_i)$ donde $d_i$ es la etiqueta y $u_i$ es el vector de entrada\n\n\n```{prf:algorithm} Algoritmo Perceptron\n:nonumber:\n\n**Hyper-parámetros:** $\\mu$\n\n1. Inicialización de los parámetros: $b=0$, $w_i=0, \\forall i = 1, \\ldots, L$\n1. Inicialización del contador: $c=0$\n2. Para $\\text{nepoch}=1,2,\\ldots, \\infty$\n 1. Hacer una permutación del dataset\n 2. $c = 0$\n 3. Para $n=1,2,\\ldots,N$\n - Si $\\text{sign} \\left(b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle \\right) \\neq d_i$ entonces\n \n $$\n \\textbf{w} = \\textbf{w} + \\mu d_n \\textbf{u}_n\n $$\n\n y\n\n $$\n b = b + \\mu d_n\n $$ \n \n de lo contrario \n\n $$\n c = c + 1 \n $$ \n \n - Si $c=N$ entonces detener el entrenamiento\n \n```\n\nNotas:\n\n- Se completa una época de entrenamiento cuando se han presentado los $N$ ejemplos del conjunto de entrenamiento\n- El hiperparámetro $\\mu$ es la tasa de aprendizaje de la neurona\n- Detenemos el entrenamiento cuando todos los ejemplos están bien clasificados. También se puede detener el entrenamiento si se cumple un cierto número fijo de épocas o al cumplir un cierto número de épocas sin cambios en $b$ y $w$\n- La permutación de los ejemplos en cada época puede evitar sesgos y acelerar la convergencia\n- El algoritmo perceptrón está garantizado a converger en tiempo finito si el problema es **linealmente separable**. Si el problema no es **linealmente separable** la convergencia se puede forzar disminuyendo gradualmente $\\mu$\n\n\n### Interpretación como una aplicación de gradiente descendente estocástico (SGD)\n\nEl algoritmo de ajuste de la neurona puede considerarse como una minimización de la siguiente función de costo\n\n$$\n\\mathcal{L}(b, \\textbf{w} ) = \\text{max} \\Big(0 ~, - d_n ( b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle) \\Big)\n$$\n\ncuya derivada es \n\n$$\n\\frac{d \\mathcal{L}}{d \\textbf{w}} = \\begin{cases} 0 & d_n ( b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle) \\geq 0 \\\\ - d_n \\textbf{u}_n & d_n ( b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle) < 0\n\\end{cases}\n$$\n\n$$\n\\frac{d \\mathcal{L}}{d b} = \\begin{cases} 0 & d_n ( b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle) \\geq 0 \\\\ - d_n & d_n ( b + \\langle \\textbf{w}, \\textbf{u}_n \\rangle) < 0\n\\end{cases}\n$$\n\nes decir que la derivada es cero si el ejemplo está bien clasificado\n\nNotemos que si aplicamos SGD sobre esta función de costo\n\n$$\n\\textbf{w} = \\textbf{w} - \\mu \\frac{d \\mathcal{L}}{d \\textbf{w}}\n$$\n\n$$\nb = b - \\mu \\frac{d \\mathcal{L}}{db}\n$$\n\nse recuperan las reglas de ajuste vistas anteriormente\n\n### Ejemplo: Clasificación binaria con perceptrón\n\nA continuación se muestra como ajustar un perceptrón a medida que se presentan los ejemplos en un problema de clasificación linealmente separable\n\n\n```python\nN = 5 # Ejemplos por clase\nL = 2 # Dimensión de los datos\nnp.random.seed(1234)\nu = np.concatenate((np.random.randn(N, L), \n 4 + np.random.randn(N, L)))\nd = np.ones(shape=(2*N,)); \nd[:N] = -1.\n```\n\n\n```python\n# Parámetros e hiperparámetros\nb, w = 0, np.zeros(shape=(L, ))\nmu = 1e-6\nmax_epoch = 2\n\nw_history = np.zeros(shape=(max_epoch*len(d), L))\nb_history = np.zeros(shape=(max_epoch*len(d),))\nu_history = np.zeros(shape=(max_epoch*len(d), 2))\n# Entrenamiento\nfor nepoch in range(max_epoch):\n idx = np.random.permutation(len(d))\n for n, (un, dn) in enumerate(zip(u[idx], d[idx])):\n if dn*(b+np.inner(w, un)) <= 0.:\n w += mu*dn*un\n b += mu*dn \n \n u_history[nepoch*len(d)+n, :] = un\n w_history[nepoch*len(d)+n, :] = w\n b_history[nepoch*len(d)+n] = b\n```\n\nLa neurona define un hiperplano que separa el espacio en dos clases. En la siguiente animación se muestra el ajuste de la neurona y en consecuencia la modificación del hiperplano. \n\n\n```python\nx_plot = np.linspace(-2, 7, num=10)\nhiperplano = lambda x, w, b : -b/(w[1]) - x*w[0]/(w[1])\n\nc1 = hv.Points((u[:N, 0], u[:N, 1]), label='Clase 1').opts(size=10, height=350, xlim=(-2, 7), ylim=(-3, 7))\nc2 = hv.Points((u[N:, 0], u[N:, 1]), label='Clase 2').opts(size=10)\np = hv.HoloMap(kdims='Iteración')\nfor i in range(len(b_history)):\n plane = hv.Curve((x_plot, hiperplano(x_plot, w_history[i, :], b_history[i])), label='Hiperplano').opts(color='k')\n selected = hv.Points((u_history[i, 0], u_history[i, 1])).opts(color='k', size=10)\n p[i] = c1 * c2 * plane * selected\n\nhv.output(p.opts(legend_position='top'), holomap='gif', fps=1)\n```\n\n\n:::{note} \n\nEl hiperplano se traslada y rota (transformación lineal) cada vez que el ejemplo seleccionado (marcado en negro) está mal clasificado\n\n:::\n\n### Más allá del perceptron \n\n- El modelo de neurona con salida sigmoide se conoce como **regresión logística**\n- Tanto el perceptrón como el regresor logístico se pueden extender a más de dos clases: **regresor softmax**\n- Conectando varias neuronas en cadena se forma lo que se conoce como una perceptrón multicapa. Este es un ejemplo de **red neuronal artificial**\n- Las redes neuronales artificiales se estudian en mayor detalle en el curso de **inteligencia artificial** (INFO257)\n\n\n\n", "meta": {"hexsha": "ce010f377f3c4c65ddcf7dbd33353b1b49b86b3b", "size": 23565, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "lectures/unit3/lecture3.ipynb", "max_stars_repo_name": "phuijse/UACH-INFO183", "max_stars_repo_head_hexsha": "0e1b6bef0bd80cda2753bd11e62016268f2de638", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2018-08-27T23:53:15.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-16T23:31:05.000Z", "max_issues_repo_path": "lectures/unit3/lecture3.ipynb", "max_issues_repo_name": "phuijse/UACH-INFO183", "max_issues_repo_head_hexsha": "0e1b6bef0bd80cda2753bd11e62016268f2de638", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lectures/unit3/lecture3.ipynb", "max_forks_repo_name": "phuijse/UACH-INFO183", "max_forks_repo_head_hexsha": "0e1b6bef0bd80cda2753bd11e62016268f2de638", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2019-01-04T17:43:55.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-07T16:07:18.000Z", "avg_line_length": 34.0534682081, "max_line_length": 284, "alphanum_fraction": 0.5186505411, "converted": true, "num_tokens": 5473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.46490157137338844, "lm_q2_score": 0.256831980010821, "lm_q1q2_score": 0.11940159108596939}}
{"text": "Probabilistic Programming\n=====\nand Bayesian Methods for Hackers \n========\n\n##### Version 0.1\n\n___\n\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\")\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to })\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load(open(\"../styles/bmh_matplotlibrc.json\"))\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head?). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\");\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\");\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\n\n```python\n# Here's what lambda ~ Exp(alpha) looks like!\n# It gives lots of weight towards small lambda. Since lambda is a parameter of the Poisson distribution,\n# this seems like the wrong distribution of lambda.\n\na = np.linspace(0, 100, 100)\nexpo = stats.expon\nalpha = 1.0/count_data.mean()\nlambda_ = [alpha]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\n# plt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,.06)\nplt.title(\"Probability density function of an Exponential random variable\");\n```\n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC3, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC3\n-----\n\nPyMC3 is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC3 is so cool.\n\nWe will model the problem above using PyMC3. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC3 framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC3 code is easy to read. The only novel thing should be the syntax. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables.\n\n\n```python\nimport pymc3 as pm\nimport theano.tensor as tt\n\nwith pm.Model() as model:\n alpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\n lambda_1 = pm.Exponential(\"lambda_1\", alpha)\n lambda_2 = pm.Exponential(\"lambda_2\", alpha)\n \n tau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data - 1)\n```\n\nIn the code above, we create the PyMC3 variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC3's *stochastic variables*, so-called because they are treated by the back end as random number generators.\n\n\n```python\nwith model:\n idx = np.arange(n_count_data) # Index\n lambda_ = pm.math.switch(tau > idx, lambda_1, lambda_2)\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. The `switch()` function assigns `lambda_1` or `lambda_2` as the value of `lambda_`, depending on what side of `tau` we are on. The values of `lambda_` up until `tau` are `lambda_1` and the values afterwards are `lambda_2`.\n\nNote that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n\n```python\nwith model:\n observation = pm.Poisson(\"obs\", lambda_, observed=count_data)\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `observed` keyword. \n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n### Mysterious code to be explained in Chapter 3.\nwith model:\n step = pm.Metropolis()\n trace = pm.sample(10000, tune=5000,step=step)\n```\n\n Multiprocess sampling (2 chains in 2 jobs)\n CompoundStep\n >Metropolis: [tau]\n >Metropolis: [lambda_2]\n >Metropolis: [lambda_1]\n\n\n\n\n\n \n
\n 100.00% [30000/30000 00:25<00:00 Sampling 2 chains, 0 divergences]\n
\n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "33bd4ba0a066f8dad33f7cee521ab090dfd6eec9", "size": 334497, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_stars_repo_name": "kennysong/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "343a0f9ccacc6051689a18ee28bc82dfbdd7ccb4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_issues_repo_name": "kennysong/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "343a0f9ccacc6051689a18ee28bc82dfbdd7ccb4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC3.ipynb", "max_forks_repo_name": "kennysong/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "343a0f9ccacc6051689a18ee28bc82dfbdd7ccb4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 255.341221374, "max_line_length": 90736, "alphanum_fraction": 0.8989886307, "converted": true, "num_tokens": 11949, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.30404167496654744, "lm_q2_score": 0.39233683016710835, "lm_q1q2_score": 0.11928674699507348}}
{"text": "```\n# this mounts your Google Drive to the Colab VM.\nfrom google.colab import drive\ndrive.mount('/content/drive', force_remount=True)\n\n# enter the foldername in your Drive where you have saved the unzipped\n# assignment folder, e.g. 'cs231n/assignments/assignment3/'\nFOLDERNAME = 'cs231n/assignments/assignment2/'\nassert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n\n# now that we've mounted your Drive, this ensures that\n# the Python interpreter of the Colab VM can load\n# python files from within it.\nimport sys\nsys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n\n# this downloads the CIFAR-10 dataset to your Drive\n# if it doesn't already exist.\n%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n!bash get_datasets.sh\n%cd /content\n```\n\n Mounted at /content/drive\n /content/drive/My Drive/cs231n/assignments/assignment2/cs231n/datasets\n /content\n\n\n# Batch Normalization\nOne way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \nOne idea along these lines is batch normalization which was proposed by [1] in 2015.\n\nThe idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n\nThe authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n\nIt is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n\n[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\nInternal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)\n\n\n```\n# As usual, a bit of setup\nimport time\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom cs231n.classifiers.fc_net import *\nfrom cs231n.data_utils import get_CIFAR10_data\nfrom cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\nfrom cs231n.solver import Solver\n\n%matplotlib inline\nplt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\nplt.rcParams['image.interpolation'] = 'nearest'\nplt.rcParams['image.cmap'] = 'gray'\n\n# for auto-reloading external modules\n# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n%load_ext autoreload\n%autoreload 2\n\ndef rel_error(x, y):\n \"\"\" returns relative error \"\"\"\n return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n\ndef print_mean_std(x,axis=0):\n print(' means: ', x.mean(axis=axis))\n print(' stds: ', x.std(axis=axis))\n print() \n```\n\n =========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n \tYou will need to compile a Cython extension for a portion of this assignment.\n \tThe instructions to do this will be given in a section of the notebook below.\n \tThere will be an option for Colab users and another for Jupyter (local) users.\n\n\n\n```\n# Load the (preprocessed) CIFAR10 data.\ndata = get_CIFAR10_data()\nfor k, v in data.items():\n print('%s: ' % k, v.shape)\n```\n\n X_train: (49000, 3, 32, 32)\n y_train: (49000,)\n X_val: (1000, 3, 32, 32)\n y_val: (1000,)\n X_test: (1000, 3, 32, 32)\n y_test: (1000,)\n\n\n## Batch normalization: forward\nIn the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n\nReferencing the paper linked to above in [1] may be helpful!\n\n\n```\n# Check the training-time forward pass by checking means and variances\n# of features both before and after batch normalization \n\n# Simulate the forward pass for a two-layer network\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before batch normalization:')\nprint_mean_std(a,axis=0)\n\ngamma = np.ones((D3,))\nbeta = np.zeros((D3,))\n# Means should be close to zero and stds close to one\nprint('After batch normalization (gamma=1, beta=0)')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n\ngamma = np.asarray([1.0, 2.0, 3.0])\nbeta = np.asarray([11.0, 12.0, 13.0])\n# Now means should be close to beta and stds close to gamma\nprint('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n```\n\n Before batch normalization:\n means: [ -2.3814598 -13.18038246 1.91780462]\n stds: [27.18502186 34.21455511 37.68611762]\n \n After batch normalization (gamma=1, beta=0)\n means: [5.32907052e-17 7.04991621e-17 1.85962357e-17]\n stds: [0.99999999 1. 1. ]\n \n After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n means: [11. 12. 13.]\n stds: [0.99999999 1.99999999 2.99999999]\n \n\n\n\n```\n# Check the test-time forward pass by running the training-time\n# forward pass many times to warm up the running averages, and then\n# checking the means and variances of activations after a test-time\n# forward pass.\n\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\n\nbn_param = {'mode': 'train'}\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n\nfor t in range(50):\n X = np.random.randn(N, D1)\n a = np.maximum(0, X.dot(W1)).dot(W2)\n batchnorm_forward(a, gamma, beta, bn_param)\n\nbn_param['mode'] = 'test'\nX = np.random.randn(N, D1)\na = np.maximum(0, X.dot(W1)).dot(W2)\na_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n\n# Means should be close to zero and stds close to one, but will be\n# noisier than training-time forward passes.\nprint('After batch normalization (test-time):')\nprint_mean_std(a_norm,axis=0)\n```\n\n After batch normalization (test-time):\n means: [-0.03927354 -0.04349152 -0.10452688]\n stds: [1.01531428 1.01238373 0.97819988]\n \n\n\n## Batch normalization: backward\nNow implement the backward pass for batch normalization in the function `batchnorm_backward`.\n\nTo derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n\nOnce you have finished, run the following to numerically check your backward pass.\n\n\n```\n# Gradient check batchnorm backward pass\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nfx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\nfg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\nfb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = batchnorm_forward(x, gamma, beta, bn_param)\ndx, dgamma, dbeta = batchnorm_backward(dout, cache)\n#You should expect to see relative errors between 1e-13 and 1e-8\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n dx error: 1.7029281043741803e-09\n dgamma error: 7.420414216247087e-13\n dbeta error: 2.8795057655839487e-12\n\n\n## Batch normalization: alternative backward\nIn class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n\nSurprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too! \n\nIn the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n\nwe first calculate the mean $\\mu$ and variance $v$.\nWith $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$ and normalized data $Y$.\nThe equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n\n\\begin{align}\n& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k & v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n& \\sigma=\\sqrt{v+\\epsilon} & y_i=\\frac{x_i-\\mu}{\\sigma}\n\\end{align}\n\n\n\nThe meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n\nThe unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n$\\frac{\\partial \\sigma}{\\partial v}$, \n$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\nand then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n\nIf it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n\nYou should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n\nAfter doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster.\n\n\n```\nnp.random.seed(231)\nN, D = 100, 500\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nout, cache = batchnorm_forward(x, gamma, beta, bn_param)\n\nt1 = time.time()\ndx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\nt2 = time.time()\ndx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\nt3 = time.time()\n\nprint('dx difference: ', rel_error(dx1, dx2))\nprint('dgamma difference: ', rel_error(dgamma1, dgamma2))\nprint('dbeta difference: ', rel_error(dbeta1, dbeta2))\nprint('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))\n```\n\n test function???\n dx difference: 9.608004855382517e-13\n dgamma difference: 0.0\n dbeta difference: 0.0\n speedup: 1.26x\n\n\n## Fully Connected Nets with Batch Normalization\nNow that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n\nConcretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n\nHINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`.\n\n\n```\nnp.random.seed(231)\nN, D, H1, H2, C = 2, 15, 20, 30, 10\nX = np.random.randn(N, D)\ny = np.random.randint(C, size=(N,))\n\n# You should expect losses between 1e-4~1e-10 for W, \n# losses between 1e-08~1e-10 for b,\n# and losses between 1e-08~1e-09 for beta and gammas.\nfor reg in [0, 3.14]:\n print('Running check with reg = ', reg)\n model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n reg=reg, weight_scale=5e-2, dtype=np.float64, \n normalization='batchnorm')\n\n\n loss, grads = model.loss(X, y)\n print('Initial loss: ', loss)\n\n for name in sorted(grads):\n f = lambda _: model.loss(X, y)[0]\n grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n if reg == 0: print()\n```\n\n Running check with reg = 0\n Initial loss: 2.4295217770600983\n W1 relative error: 1.47e-05\n W2 relative error: 2.46e-06\n W3 relative error: 2.87e-09\n b1 relative error: 4.15e-06\n b2 relative error: 8.72e-07\n b3 relative error: 1.04e-10\n beta1 relative error: 1.38e-07\n beta2 relative error: 3.55e-09\n gamma1 relative error: 6.30e-08\n gamma2 relative error: 2.74e-09\n \n Running check with reg = 3.14\n Initial loss: 7.161193776133827\n W1 relative error: 1.64e-05\n W2 relative error: 8.17e-07\n W3 relative error: 1.00e+00\n b1 relative error: 1.62e-05\n b2 relative error: 7.75e-07\n b3 relative error: 1.38e-10\n beta1 relative error: 1.69e-08\n beta2 relative error: 5.19e-09\n gamma1 relative error: 8.22e-09\n gamma2 relative error: 9.13e-09\n\n\n# Batchnorm for deep networks\nRun the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization.\n\n\n```\nnp.random.seed(231)\n# Try training a very deep net with batchnorm\nhidden_dims = [100, 100, 100, 100, 100]\n\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nweight_scale = 2e-2\nbn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\nmodel = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\nprint('Solver with batch norm:')\nbn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True,print_every=20)\nbn_solver.train()\n\nprint('\\nSolver without batch norm:')\nsolver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True, print_every=20)\nsolver.train()\n```\n\n Solver with batch norm:\n (Iteration 1 / 200) loss: 2.368423\n (Epoch 0 / 10) train acc: 0.101000; val_acc: 0.107000\n (Epoch 1 / 10) train acc: 0.307000; val_acc: 0.252000\n (Iteration 21 / 200) loss: 1.925888\n (Epoch 2 / 10) train acc: 0.447000; val_acc: 0.311000\n (Iteration 41 / 200) loss: 1.989997\n (Epoch 3 / 10) train acc: 0.521000; val_acc: 0.274000\n (Iteration 61 / 200) loss: 1.784510\n (Epoch 4 / 10) train acc: 0.598000; val_acc: 0.295000\n (Iteration 81 / 200) loss: 1.231503\n (Epoch 5 / 10) train acc: 0.577000; val_acc: 0.283000\n (Iteration 101 / 200) loss: 1.194501\n (Epoch 6 / 10) train acc: 0.689000; val_acc: 0.343000\n (Iteration 121 / 200) loss: 0.907169\n (Epoch 7 / 10) train acc: 0.735000; val_acc: 0.302000\n (Iteration 141 / 200) loss: 1.044532\n (Epoch 8 / 10) train acc: 0.748000; val_acc: 0.314000\n (Iteration 161 / 200) loss: 0.754309\n (Epoch 9 / 10) train acc: 0.779000; val_acc: 0.301000\n (Iteration 181 / 200) loss: 0.800480\n (Epoch 10 / 10) train acc: 0.808000; val_acc: 0.311000\n \n Solver without batch norm:\n (Iteration 1 / 200) loss: 2.302332\n (Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n (Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n (Iteration 21 / 200) loss: 2.041970\n (Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n (Iteration 41 / 200) loss: 1.900473\n (Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n (Iteration 61 / 200) loss: 1.713156\n (Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n (Iteration 81 / 200) loss: 1.662209\n (Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n (Iteration 101 / 200) loss: 1.696059\n (Epoch 6 / 10) train acc: 0.535000; val_acc: 0.345000\n (Iteration 121 / 200) loss: 1.557987\n (Epoch 7 / 10) train acc: 0.530000; val_acc: 0.304000\n (Iteration 141 / 200) loss: 1.432189\n (Epoch 8 / 10) train acc: 0.628000; val_acc: 0.339000\n (Iteration 161 / 200) loss: 1.034116\n (Epoch 9 / 10) train acc: 0.654000; val_acc: 0.342000\n (Iteration 181 / 200) loss: 0.905795\n (Epoch 10 / 10) train acc: 0.712000; val_acc: 0.328000\n\n\nRun the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster.\n\n\n```\ndef plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n \"\"\"utility function for plotting training history\"\"\"\n plt.title(title)\n plt.xlabel(label)\n bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n bl_plot = plot_fn(baseline)\n num_bn = len(bn_plots)\n for i in range(num_bn):\n label='with_norm'\n if labels is not None:\n label += str(labels[i])\n plt.plot(bn_plots[i], bn_marker, label=label)\n label='baseline'\n if labels is not None:\n label += str(labels[0])\n plt.plot(bl_plot, bl_marker, label=label)\n plt.legend(loc='lower center', ncol=num_bn+1) \n\n \nplt.subplot(3, 1, 1)\nplot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n lambda x: x.loss_history, bl_marker='o', bn_marker='o')\nplt.subplot(3, 1, 2)\nplot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\nplt.subplot(3, 1, 3)\nplot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n# Batch normalization and initialization\nWe will now run a small experiment to study the interaction of batch normalization and weight initialization.\n\nThe first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale.\n\n\n```\nnp.random.seed(231)\n# Try training a very deep net with batchnorm\nhidden_dims = [50, 50, 50, 50, 50, 50, 50]\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nbn_solvers_ws = {}\nsolvers_ws = {}\nweight_scales = np.logspace(-4, 0, num=20)\nfor i, weight_scale in enumerate(weight_scales):\n print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\n bn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n bn_solver.train()\n bn_solvers_ws[weight_scale] = bn_solver\n\n solver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n solver.train()\n solvers_ws[weight_scale] = solver\n```\n\n Running weight scale 1 / 20\n Running weight scale 2 / 20\n Running weight scale 3 / 20\n Running weight scale 4 / 20\n Running weight scale 5 / 20\n Running weight scale 6 / 20\n Running weight scale 7 / 20\n Running weight scale 8 / 20\n Running weight scale 9 / 20\n Running weight scale 10 / 20\n Running weight scale 11 / 20\n Running weight scale 12 / 20\n Running weight scale 13 / 20\n Running weight scale 14 / 20\n Running weight scale 15 / 20\n Running weight scale 16 / 20\n Running weight scale 17 / 20\n Running weight scale 18 / 20\n Running weight scale 19 / 20\n Running weight scale 20 / 20\n\n\n\n```\n# Plot results of weight scale experiment\nbest_train_accs, bn_best_train_accs = [], []\nbest_val_accs, bn_best_val_accs = [], []\nfinal_train_loss, bn_final_train_loss = [], []\n\nfor ws in weight_scales:\n best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n \n best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n \n final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n \nplt.subplot(3, 1, 1)\nplt.title('Best val accuracy vs weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best val accuracy')\nplt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\nplt.legend(ncol=2, loc='lower right')\n\nplt.subplot(3, 1, 2)\nplt.title('Best train accuracy vs weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best training accuracy')\nplt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\nplt.legend()\n\nplt.subplot(3, 1, 3)\nplt.title('Final training loss vs weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Final training loss')\nplt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\nplt.legend()\nplt.gca().set_ylim(1.0, 3.5)\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n## Inline Question 1:\nDescribe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?\n\n## Answer:\nFrom the experiment, we can see that with batch normalization, the network is more stable with reasonable result over wide range of weight initilization and almost always better than the network without batch normalization layers by the same weight initialization. Without the batch normalization layers, the network only yeilds good results in small range of weight intialization. And after some weight initialization thresholds, both networks start perform poorly.\n\nEvery layers' weights are initialized with the same weight scale. However, without batch normalization, the mean and variance of input values for each layer varies a lot from each other. So, if the weight scale works (help the training to converge) for a layer, it does not garantee to work with other layers, because the input values is in the different range (different means and variances). It is not the case for networks with batch normalization layers, because the batch norm layers garantee the output of each layer is normalized to have mean 0 and 1 standard deviation, and then scale and shift the values by 2 learned parameter gamma and beta. In other words, the input values are consistent over the layers, make it possiple for the model to converge with large range of weight scales.\n\n\n# Batch normalization and batch size\nWe will now run a small experiment to study the interaction of batch normalization and batch size.\n\nThe first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time.\n\n\n```\ndef run_batchsize_experiments(normalization_mode):\n np.random.seed(231)\n # Try training a very deep net with batchnorm\n hidden_dims = [100, 100, 100, 100, 100]\n num_train = 1000\n small_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n }\n n_epochs=10\n weight_scale = 2e-2\n batch_sizes = [5,10,50]\n lr = 10**(-3.5)\n solver_bsize = batch_sizes[0]\n\n print('No normalization: batch size = ',solver_bsize)\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n solver = Solver(model, small_data,\n num_epochs=n_epochs, batch_size=solver_bsize,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n solver.train()\n \n bn_solvers = []\n for i in range(len(batch_sizes)):\n b_size=batch_sizes[i]\n print('Normalization: batch size = ', b_size)\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n bn_solver = Solver(bn_model, small_data,\n num_epochs=n_epochs, batch_size=b_size,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n bn_solver.train()\n bn_solvers.append(bn_solver)\n \n return bn_solvers, solver, batch_sizes\n\nbatch_sizes = [5,10,50]\nbn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')\n```\n\n No normalization: batch size = 5\n Normalization: batch size = 5\n Normalization: batch size = 10\n Normalization: batch size = 50\n\n\n\n```\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 2:\nDescribe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n\n## Answer:\nAccording to the result, we can see that the performance of batch normalization is affected by the batch size. Specifictly, the smaller the batch size the worse. From the result, the batch normalization net with smallest batch size even perform worse than the baseline. The reason for this problem is that the batch normalization layers estimates the entire dataset statistics by caculating the statictis of each batch. Small batch will result in more noise in the statistics and make the model perform poorly.\n\n\n# Layer Normalization\nBatch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n\nSeveral alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n\n[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)\n\n## Inline Question 3:\nWhich of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n\n1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1. \n3. Subtracting the mean image of the dataset from each image in the dataset.\n4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n\n## Answer:\n3. Batch Normalization: gamma = 1/std, beta =0\n\n\n# Layer Normalization: Implementation\n\nNow you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n\nHere's what you need to do:\n\n* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`. \n\nRun the cell below to check your results.\n* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n\nRun the second cell below to check your results.\n* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n\nRun the third cell below to run the batch size experiment on layer normalization.\n\n\n```\n# Check the training-time forward pass by checking means and variances\n# of features both before and after layer normalization \n\n# Simulate the forward pass for a two-layer network\nnp.random.seed(231)\nN, D1, D2, D3 =4, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before layer normalization:')\nprint_mean_std(a,axis=1)\n\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n# Means should be close to zero and stds close to one\nprint('After layer normalization (gamma=1, beta=0)')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n\ngamma = np.asarray([3.0,3.0,3.0])\nbeta = np.asarray([5.0,5.0,5.0])\n# Now means should be close to beta and stds close to gamma\nprint('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n```\n\n Before layer normalization:\n means: [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n stds: [10.07429373 28.39478981 35.28360729 4.01831507]\n \n After layer normalization (gamma=1, beta=0)\n means: [ 4.81096644e-16 -7.40148683e-17 2.22044605e-16 -5.92118946e-16]\n stds: [0.99999995 0.99999999 1. 0.99999969]\n \n After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n means: [5. 5. 5. 5.]\n stds: [2.99999985 2.99999998 2.99999999 2.99999907]\n \n\n\n\n```\n# Gradient check batchnorm backward pass\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nln_param = {}\nfx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\nfg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\nfb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = layernorm_forward(x, gamma, beta, ln_param)\ndx, dgamma, dbeta = layernorm_backward(dout, cache)\n\n#You should expect to see relative errors between 1e-12 and 1e-8\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n function test3\n dx error: 1.4336158494902849e-09\n dgamma error: 4.519489546032799e-12\n dbeta error: 2.276445013433725e-12\n\n\n# Layer Normalization and batch size\n\nWe will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!\n\n\n```\ndef run_dimsize_experiments(normalization_mode):\n np.random.seed(231)\n # Try training a very deep net with batchnorm\n batch_size = 32\n dims = [[5] * 4, [10] * 4, [20] * 4, [50] * 4]\n num_train = 1000\n small_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n }\n n_epochs=10\n weight_scale = 2e-2\n batch_sizes = [5,10,50]\n lr = 10**(-3.5)\n solver_dim = dims[0]\n\n print('No normalization: dim size = ', dims[0][0])\n model = FullyConnectedNet(dims[0], weight_scale=weight_scale, normalization=None)\n solver = Solver(model, small_data,\n num_epochs=n_epochs, batch_size=batch_size,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n solver.train()\n \n bn_solvers = []\n for i in range(len(dims)):\n dims_ = dims[i]\n print('Normalization: dim size = ', dims_[0])\n bn_model = FullyConnectedNet(dims_, weight_scale=weight_scale, normalization=normalization_mode)\n bn_solver = Solver(bn_model, small_data,\n num_epochs=n_epochs, batch_size=batch_size,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n bn_solver.train()\n bn_solvers.append(bn_solver)\n \n return bn_solvers, solver, batch_sizes\n```\n\n\n```\nln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n\n```\nln_solvers_dsize, solver_dsize, batch_sizes = run_dimsize_experiments('layernorm')\n\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_dsize, ln_solvers_dsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=[5, 10, 20, 50])\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_dsize, ln_solvers_dsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=[5, 10, 20, 50])\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 4:\nWhen is layer normalization likely to not work well, and why?\n\n1. Using it in a very deep network\n2. Having a very small dimension of features\n3. Having a high regularization term\n\n\n## Answer:\n1. [INCORRECT] According the above result, trained with 5 layers which is considered to be deep, the network still works well with layer normalization\n2. [CORRECT] It is like the problem with small batch size in batch.normalization. The layer normalization caculates the statistics of the on each data point, having too small number of dimensions makes the statistics noiser and reduces the representation of the data points.\n3. [CORRECT] Having a high regularization term prevent the network from learning the complex transformations and potentially underfits the training data.\n\n\n\n```\n\n```\n", "meta": {"hexsha": "29ac058aff49e4add43ee61e691543e459643477", "size": 541772, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignment2/BatchNormalization.ipynb", "max_stars_repo_name": "quochungto/stanford-cs231n-assignment-solution", "max_stars_repo_head_hexsha": "22f6a97f29c4188d57a581822ce1dbd37a36b882", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "assignment2/BatchNormalization.ipynb", "max_issues_repo_name": "quochungto/stanford-cs231n-assignment-solution", "max_issues_repo_head_hexsha": "22f6a97f29c4188d57a581822ce1dbd37a36b882", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "assignment2/BatchNormalization.ipynb", "max_forks_repo_name": "quochungto/stanford-cs231n-assignment-solution", "max_forks_repo_head_hexsha": "22f6a97f29c4188d57a581822ce1dbd37a36b882", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 541772.0, "max_line_length": 541772, "alphanum_fraction": 0.9393102634, "converted": true, "num_tokens": 10288, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4571367168274948, "lm_q2_score": 0.25982564369245537, "lm_q1q2_score": 0.11877584170515952}}
{"text": "\n\n\n# PHY321: Conservative forces, examples and theory\n**[Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/)**, Department of Physics and Astronomy and Facility for Rare Ion Beams (FRIB), Michigan State University, USA and Department of Physics, University of Oslo, Norway\n\nDate: **Feb 18, 2022**\n\nCopyright 1999-2022, [Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/). Released under CC Attribution-NonCommercial 4.0 license\n\n## Aims and Overarching Motivation\n\n### Monday February 14\n\nDiscussion of conditions for conservative forces and summing up our\ndiscussion on conservative forces. Discussion of potential surfaces\nand their interpretations. \n\n**Reading suggestion**: Taylor sections 4.6, 4.9, 4.10 and 5.1 and 5.2 on harmonic oscillations.\n\n### Wednesday February 16\n\nThe Earth-Sun problem and energy-conserving algorithms and how to encode in more efficient ways various algorithms for solving the equations of motion (Euler, Euler-Cromer and Velocity Verlet).\n\n* [Links to Julie's material on code reusability](https://github.com/mhjensen/Physics321/tree/master/doc/pub/week7/ipynb)\n\n**Reading suggestions**: Taylor section 4.8 and these notes\n\n### Friday February 18\n\nWorking on the Earth-Sun problem and hw 5. Hints on various exercises.\n\n**Reading suggestions:** Taylor chapters 3 and 4 and these notes.\n\n## The curl of a force and link between Line Integrals and conservative forces\n\nThe concept of line integrals plays an important role in our discussion of energy conservation,\nour definition of potentials and conservative forces.\n\nLet us remind ourselves of some the basic elements (most of you may\nhave seen this in a calculus course under the general topic of vector\nfields).\n\nWe define a path integration $C$, that is we integrate\nfrom a point $\\boldsymbol{r}_1$ to a point $\\boldsymbol{r}_2$. \nLet us assume that the path $C$ is represented by an arc length $s$. In three dimension we have the following representation of $C$\n\n$$\n\\boldsymbol{r}(s)=x(s)\\boldsymbol{e}_1+y(s)\\boldsymbol{e}_2+z(s)\\boldsymbol{e}_3,\n$$\n\nthen our integral of a function $f(x,y,z)$ along the path $C$ is defined as\n\n$$\n\\int_Cf(x,y,z)ds=\\int_a^bf\\left(x(s),y(s),z(s)\\right)ds,\n$$\n\nwhere the initial and final points are $a$ and $b$, respectively.\n\n## Exactness and Independence of Path\n\nWith the definition of a line integral, we can in turn set up the\ntheorem of independence of integration path.\n\nLet us define\n$f(x,y,z)$, $g(x,y,z)$ and $h(x,y,z)$ to be functions which are\ndefined and continuous in a domain $D$ in space. Then a line integral\nlike the above is said to be independent of path in $D$, if for every\npair of endpoints $a$ and $b$ in $D$ the value of the integral is the\nsame for all paths $C$ in $D$ starting from a point $a$ and ending in\na point $b$. The integral depends thus only on the integration limits\nand not on the path.\n\n## Differential Forms\n\nAn expression of the form\n\n$$\nfdx+gdy+hdz,\n$$\n\nwhere $f$, $g$ and $h$ are functions defined in $D$, is a called a first-order differential form\nin three variables.\nThe form is said to be exact if it is the differential\n\n$$\ndu= \\frac{\\partial u}{\\partial x}dx+\\frac{\\partial u}{\\partial y}dy+\\frac{\\partial u}{\\partial z}dz,\n$$\n\nof a differentiable function $u(x,y,z)$ everywhere in $D$, that is\n\n$$\ndu=fdx+gdy+hdz.\n$$\n\nIt is said to be exact if and only if we can then set\n\n$$\nf=\\frac{\\partial u}{\\partial x},\n$$\n\nand\n\n$$\ng=\\frac{\\partial u}{\\partial y},\n$$\n\nand\n\n$$\nh=\\frac{\\partial u}{\\partial z},\n$$\n\neverywhere in the domain $D$.\n\n## In Vector Language\n\nIn vector language the above means that the differential form\n\n$$\nfdx+gdy+hdz,\n$$\n\nis exact in $D$ if and only if the vector function (it could be a force, or velocity, acceleration or other vectors we encounter in this course)\n\n$$\n\\boldsymbol{F}=f\\boldsymbol{e}_1+g\\boldsymbol{e}_2+h\\boldsymbol{e}_3,\n$$\n\nis the gradient of a function $u(x,y,z)$\n\n$$\n\\boldsymbol{v}=\\boldsymbol{\\nabla}u=\\frac{\\partial u}{\\partial x}\\boldsymbol{e}_1+\\frac{\\partial u}{\\partial y}\\boldsymbol{e}_2+\\frac{\\partial u}{\\partial z}\\boldsymbol{e}_3.\n$$\n\n## Path Independence Theorem\n\nIf this is the case, we can state the path independence theorem which\nstates that with functions $f(x,y,z)$, $g(x,y,z)$ and $h(x,y,z)$ that fulfill the above\nexactness conditions, the line integral\n\n$$\n\\int_C\\left(fdx+gdy+hdz\\right),\n$$\n\nis independent of path in $D$ if and only if the differential form under the integral sign is exact in $D$.\n\nThis is the path independence theorem. \n\nWe will not give a proof of the theorem. You can find this in any vector analysis chapter in a mathematics textbook.\n\nWe note however that the path integral from a point $p$ to a final point $q$ is given by\n\n$$\n\\int_p^q\\left(fdx+gdy+hdz\\right)=\\int_p^q\\left(\\frac{\\partial u}{\\partial x}dx+\\frac{\\partial u}{\\partial y}dy+\\frac{\\partial u}{\\partial z}dz\\right)=\\int_p^qdu.\n$$\n\nAssume now that we have a dependence on a variable $s$ for $x$, $y$ and $z$. We have then\n\n$$\n\\int_p^qdu=\\int_{s_1}^{s_2}\\frac{du}{ds}ds = u(x(s),y(s),z(s))\\vert_{s=s_1}^{s=s_2}=u(q)-u(p).\n$$\n\nThis last equation\n\n$$\n\\int_p^q\\left(fdx+gdy+hdz\\right)=u(q)-u(p),\n$$\n\nis the analogue of the usual formula\n\n$$\n\\int_a^bf(x)dx=F(x)\\vert_a^b=F(b)-F(a),\n$$\n\nwith $F'(x)=f(x)$.\n\n## Work-Energy Theorem again\n\nWe remember that a the work done by a force\n$\\boldsymbol{F}=f\\boldsymbol{e}_1+g\\boldsymbol{e}_2+h\\boldsymbol{e}_3$ on a displacemnt $d\\boldsymbol{r}$\n\n$$\nW=\\int_C\\boldsymbol{F}d\\boldsymbol{r}=\\int_C(fdx+gdy+hdz).\n$$\n\nFrom the path independence theorem, we know that this has to result in\nthe difference between the two endpoints only. This is exact if and\nonly if the force is the force $\\boldsymbol{F}$ is the gradient of a scalar\nfunction $u$. We call this scalar function, which depends only the\npositions $x,y,z$ for the potential energy $V(x,y,z)=V(\\boldsymbol{r})$.\n\nWe have thus\n\n$$\n\\boldsymbol{F}(\\boldsymbol{r})\\propto \\boldsymbol{\\nabla}V(\\boldsymbol{r}),\n$$\n\nand we define this as\n\n$$\n\\boldsymbol{F}(\\boldsymbol{r})= -\\boldsymbol{\\nabla}V(\\boldsymbol{r}).\n$$\n\nSuch a force is called **a conservative force**. The above expression can be used to demonstrate\nenergy conservation.\n\n## Additional Theorem\n\nFinally we can define the criterion for exactness and independence of\npath. This theorem states that if $f(x,y,z)$, $g(x,y,z)$ and\n$h(x,y,z)$ are continuous functions with continuous first partial derivatives in the domain $D$,\nthen the line integral\n\n$$\n\\int_C\\left(fdx+gdy+hdz\\right),\n$$\n\nis independent of path in $D$ when\n\n$$\n\\frac{\\partial h}{\\partial y}=\\frac{\\partial g}{\\partial z},\n$$\n\nand\n\n$$\n\\frac{\\partial f}{\\partial z}=\\frac{\\partial h}{\\partial x},\n$$\n\nand\n\n$$\n\\frac{\\partial g}{\\partial x}=\\frac{\\partial f}{\\partial y}.\n$$\n\nThis leads to the **curl** of $\\boldsymbol{F}$ being zero\n\n$$\n\\boldsymbol{\\nabla}\\times\\boldsymbol{F}=\\boldsymbol{\\nabla}\\times\\left(-\\boldsymbol{\\nabla}V(\\boldsymbol{r})\\right)=0!\n$$\n\n## Summarizing\n\nA conservative force $\\boldsymbol{F}$ is a defined as the partial derivative of a scalar potential which depends only on the position,\n\n$$\n\\boldsymbol{F}(\\boldsymbol{r})= -\\boldsymbol{\\nabla}V(\\boldsymbol{r}).\n$$\n\nThis leads to conservation of energy and a path independent line integral as long as the curl of the force is zero, that is\n\n$$\n\\boldsymbol{\\nabla}\\times\\boldsymbol{F}=\\boldsymbol{\\nabla}\\times\\left(-\\boldsymbol{\\nabla}V(\\boldsymbol{r})\\right)=0.\n$$\n\n## Graphing the potential energy and what we can learn from that\n\nThis is taken from homework 4, exercises 5.\n\nA particle is under the influence of a force $F=-kx+kx^3/\\alpha^2$, where $k$ and $\\alpha$ are constants and $k$ is positive.\n\nDetermine $V(x)$ and discuss the motion. It can be convenient here to\nmake a sketch/plot of the potential as function of $x$.\n\nWe assume that the potential is zero at say $x=0$. Integrating the force from zero to $x$ gives\n\n$$\nV(x) = -\\int_0^x F(x')dx'=\\frac{kx^2}{2}-\\frac{kx^4}{4\\alpha^2}.\n$$\n\n## Making the plot\n\nThe following code plots the potential. We have chosen values of $\\alpha=k=1.0$. Feel free to experiment with other values. We plot $V(x)$ for a domain of $x\\in [-2,2]$.\n\n\n```\n%matplotlib inline\n\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport math\n\nx0= -2.0\nxn = 2.1\nDeltax = 0.1\nalpha = 1.0\nk = 1.0\n#set up arrays\nx = np.arange(x0,xn,Deltax)\nn = np.size(x)\nV = np.zeros(n)\nV = 0.5*k*x*x-0.25*k*(x**4)/(alpha*alpha)\nplt.plot(x, V)\nplt.xlabel(\"x\")\nplt.ylabel(\"V\")\nplt.show()\n```\n\n## Interpreting the results\n\nFrom the plot here (with the chosen parameters) \n1. we see that with a given initial velocity we can overcome the potential energy barrier\n\nand leave the potential well for good.\n1. If the initial velocity is smaller (see next exercise) than a certain value, it will remain trapped in the potential well and oscillate back and forth around $x=0$. This is where the potential has its minimum value. \n\n2. If the kinetic energy at $x=0$ equals the maximum potential energy, the object will oscillate back and forth between the minimum potential energy at $x=0$ and the turning points where the kinetic energy turns zero. These are the so-called non-equilibrium points.\n\n## Final interpretations\n\nWhat happens when the energy of the particle is $E=(1/4)k\\alpha^2$? Hint: what is the maximum value of the potential energy?\n\nFrom the figure we see that\nthe potential has a minimum at at $x=0$ then rises until $x=\\alpha$ before falling off again. The maximum\npotential, $V(x\\pm \\alpha) = k\\alpha^2/4$. If the energy is higher, the particle cannot be contained in the\nwell. The turning points are thus defined by $x=\\pm \\alpha$. And from the previous plot you can easily see that this is the case ($\\alpha=1$ in the abovementioned Python code).\n\n## The Earth-Sun system\n\nWe will now venture into a study of a system which is energy\nconserving. The aim is to see if we (since it is not possible to solve\nthe general equations analytically) we can develop stable numerical\nalgorithms whose results we can trust!\n\nWe solve the equations of motion numerically. We will also compute\nquantities like the energy numerically.\n\nWe start with a simpler case first, the Earth-Sun system in two dimensions only. The gravitational force $F_G$ on the earth from the sun is\n\n$$\n\\boldsymbol{F}_G=-\\frac{GM_{\\odot}M_E}{r^3}\\boldsymbol{r},\n$$\n\nwhere $G$ is the gravitational constant,\n\n$$\nM_E=6\\times 10^{24}\\mathrm{Kg},\n$$\n\nthe mass of Earth,\n\n$$\nM_{\\odot}=2\\times 10^{30}\\mathrm{Kg},\n$$\n\nthe mass of the Sun and\n\n$$\nr=1.5\\times 10^{11}\\mathrm{m},\n$$\n\nis the distance between Earth and the Sun. The latter defines what we call an astronomical unit **AU**.\n\n## The Earth-Sun system, Newton's Laws\n\nFrom Newton's second law we have then for the $x$ direction\n\n$$\n\\frac{d^2x}{dt^2}=-\\frac{F_{x}}{M_E},\n$$\n\nand\n\n$$\n\\frac{d^2y}{dt^2}=-\\frac{F_{y}}{M_E},\n$$\n\nfor the $y$ direction.\n\nHere we will use that $x=r\\cos{(\\theta)}$, $y=r\\sin{(\\theta)}$ and\n\n$$\nr = \\sqrt{x^2+y^2}.\n$$\n\nWe can rewrite\n\n$$\nF_{x}=-\\frac{GM_{\\odot}M_E}{r^2}\\cos{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}x,\n$$\n\nand\n\n$$\nF_{y}=-\\frac{GM_{\\odot}M_E}{r^2}\\sin{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}y,\n$$\n\nfor the $y$ direction.\n\n## The Earth-Sun system, rewriting the Equations\n\nWe can rewrite these two equations\n\n$$\nF_{x}=-\\frac{GM_{\\odot}M_E}{r^2}\\cos{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}x,\n$$\n\nand\n\n$$\nF_{y}=-\\frac{GM_{\\odot}M_E}{r^2}\\sin{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}y,\n$$\n\nas four first-order coupled differential equations\n\n$$\n\\frac{dv_x}{dt}=-\\frac{GM_{\\odot}}{r^3}x,\n$$\n\n$$\n\\frac{dx}{dt}=v_x,\n$$\n\n$$\n\\frac{dv_y}{dt}=-\\frac{GM_{\\odot}}{r^3}y,\n$$\n\n$$\n\\frac{dy}{dt}=v_y.\n$$\n\n## Building a code for the solar system, final coupled equations\n\nThe four coupled differential equations\n\n$$\n\\frac{dv_x}{dt}=-\\frac{GM_{\\odot}}{r^3}x,\n$$\n\n$$\n\\frac{dx}{dt}=v_x,\n$$\n\n$$\n\\frac{dv_y}{dt}=-\\frac{GM_{\\odot}}{r^3}y,\n$$\n\n$$\n\\frac{dy}{dt}=v_y,\n$$\n\ncan be turned into dimensionless equations or we can introduce astronomical units with $1$ AU = $1.5\\times 10^{11}$. \n\nUsing the equations from circular motion (with $r =1\\mathrm{AU}$)\n\n$$\n\\frac{M_E v^2}{r} = F = \\frac{GM_{\\odot}M_E}{r^2},\n$$\n\nwe have\n\n$$\nGM_{\\odot}=v^2r,\n$$\n\nand using that the velocity of Earth (assuming circular motion) is\n$v = 2\\pi r/\\mathrm{yr}=2\\pi\\mathrm{AU}/\\mathrm{yr}$, we have\n\n$$\nGM_{\\odot}= v^2r = 4\\pi^2 \\frac{(\\mathrm{AU})^3}{\\mathrm{yr}^2}.\n$$\n\n## Building a code for the solar system, discretized equations\n\nThe four coupled differential equations can then be discretized using Euler's method as (with step length $h$)\n\n$$\nv_{x,i+1}=v_{x,i}-h\\frac{4\\pi^2}{r_i^3}x_i,\n$$\n\n$$\nx_{i+1}=x_i+hv_{x,i},\n$$\n\n$$\nv_{y,i+1}=v_{y,i}-h\\frac{4\\pi^2}{r_i^3}y_i,\n$$\n\n$$\ny_{i+1}=y_i+hv_{y,i},\n$$\n\n## Code Example with Euler's Method\n\nThe code here implements Euler's method for the Earth-Sun system using a more compact way of representing the vectors. Alternatively, you could have spelled out all the variables $v_x$, $v_y$, $x$ and $y$ as one-dimensional arrays.\n\n\n```\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\nDeltaT = 0.001\n#set up arrays \ntfinal = 10 # in years\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and x\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions as compact 2-dimensional arrays\nr0 = np.array([1.0,0.0])\nv0 = np.array([0.0,2*pi])\nr[0] = r0\nv[0] = v0\nFourpi2 = 4*pi*pi\n# Start integrating using Euler's method\nfor i in range(n-1):\n # Set up the acceleration\n # Here you could have defined your own function for this\n rabs = sqrt(sum(r[i]*r[i]))\n a = -Fourpi2*r[i]/(rabs**3)\n # update velocity, time and position using Euler's forward method\n v[i+1] = v[i] + DeltaT*a\n r[i+1] = r[i] + DeltaT*v[i]\n t[i+1] = t[i] + DeltaT\n# Plot position as function of time \nfig, ax = plt.subplots()\n#ax.set_xlim(0, tfinal)\nax.set_ylabel('y[AU]')\nax.set_xlabel('x[AU]')\nax.plot(r[:,0], r[:,1])\nfig.tight_layout()\nsave_fig(\"EarthSunEuler\")\nplt.show()\n```\n\n## Problems with Euler's Method\n\nWe notice here that Euler's method doesn't give a stable orbit. It\nmeans that we cannot trust Euler's method. In a deeper way, as we will\nsee in homework 5, Euler's method does not conserve energy. It is an\nexample of an integrator which is not\n[symplectic](https://en.wikipedia.org/wiki/Symplectic_integrator).\n\nHere we present thus two methods, which with simple changes allow us to avoid these pitfalls. The simplest possible extension is the so-called Euler-Cromer method.\nThe changes we need to make to our code are indeed marginal here.\nWe need simply to replace\n\n\n```\n r[i+1] = r[i] + DeltaT*v[i]\n```\n\nin the above code with the velocity at the new time $t_{i+1}$\n\n\n```\n r[i+1] = r[i] + DeltaT*v[i+1]\n```\n\nBy this simple caveat we get stable orbits.\nBelow we derive the Euler-Cromer method as well as one of the most utlized algorithms for sovling the above type of problems, the so-called Velocity-Verlet method.\n\n## Deriving the Euler-Cromer Method\n\nLet us repeat Euler's method.\nWe have a differential equation\n\n\n
\n\n$$\n\\begin{equation}\ny'(t_i)=f(t_i,y_i) \n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nand if we truncate at the first derivative, we have from the Taylor expansion\n\n\n
\n\n$$\n\\begin{equation}\ny_{i+1}=y(t_i) + (\\Delta t) f(t_i,y_i) + O(\\Delta t^2), \\label{eq:euler} \\tag{2}\n\\end{equation}\n$$\n\nwhich when complemented with $t_{i+1}=t_i+\\Delta t$ forms\nthe algorithm for the well-known Euler method. \nNote that at every step we make an approximation error\nof the order of $O(\\Delta t^2)$, however the total error is the sum over all\nsteps $N=(b-a)/(\\Delta t)$ for $t\\in [a,b]$, yielding thus a global error which goes like\n$NO(\\Delta t^2)\\approx O(\\Delta t)$. \n\nTo make Euler's method more precise we can obviously\ndecrease $\\Delta t$ (increase $N$), but this can lead to loss of numerical precision.\nEuler's method is not recommended for precision calculation,\nalthough it is handy to use in order to get a first\nview on how a solution may look like.\n\nEuler's method is asymmetric in time, since it uses information about the derivative at the beginning\nof the time interval. This means that we evaluate the position at $y_1$ using the velocity\nat $v_0$. A simple variation is to determine $x_{n+1}$ using the velocity at\n$v_{n+1}$, that is (in a slightly more generalized form)\n\n\n
\n\n$$\n\\begin{equation} \ny_{n+1}=y_{n}+ v_{n+1}+O(\\Delta t^2)\n\\label{_auto2} \\tag{3}\n\\end{equation}\n$$\n\nand\n\n\n
\n\n$$\n\\begin{equation}\nv_{n+1}=v_{n}+(\\Delta t) a_{n}+O(\\Delta t^2).\n\\label{_auto3} \\tag{4}\n\\end{equation}\n$$\n\nThe acceleration $a_n$ is a function of $a_n(y_n, v_n, t_n)$ and needs to be evaluated\nas well. This is the Euler-Cromer method.\n\n**Exercise**: go back to the above code with Euler's method and add the Euler-Cromer method.\n\n## Deriving the Velocity-Verlet Method\n\nLet us stay with $x$ (position) and $v$ (velocity) as the quantities we are interested in.\n\nWe have the Taylor expansion for the position given by\n\n$$\nx_{i+1} = x_i+(\\Delta t)v_i+\\frac{(\\Delta t)^2}{2}a_i+O((\\Delta t)^3).\n$$\n\nThe corresponding expansion for the velocity is\n\n$$\nv_{i+1} = v_i+(\\Delta t)a_i+\\frac{(\\Delta t)^2}{2}v^{(2)}_i+O((\\Delta t)^3).\n$$\n\nVia Newton's second law we have normally an analytical expression for the derivative of the velocity, namely\n\n$$\na_i= \\frac{d^2 x}{dt^2}\\vert_{i}=\\frac{d v}{dt}\\vert_{i}= \\frac{F(x_i,v_i,t_i)}{m}.\n$$\n\nIf we add to this the corresponding expansion for the derivative of the velocity\n\n$$\nv^{(1)}_{i+1} = a_{i+1}= a_i+(\\Delta t)v^{(2)}_i+O((\\Delta t)^2)=a_i+(\\Delta t)v^{(2)}_i+O((\\Delta t)^2),\n$$\n\nand retain only terms up to the second derivative of the velocity since our error goes as $O(h^3)$, we have\n\n$$\n(\\Delta t)v^{(2)}_i\\approx a_{i+1}-a_i.\n$$\n\nWe can then rewrite the Taylor expansion for the velocity as\n\n$$\nv_{i+1} = v_i+\\frac{(\\Delta t)}{2}\\left( a_{i+1}+a_{i}\\right)+O((\\Delta t)^3).\n$$\n\n## The velocity Verlet method\n\nOur final equations for the position and the velocity become then\n\n$$\nx_{i+1} = x_i+(\\Delta t)v_i+\\frac{(\\Delta t)^2}{2}a_{i}+O((\\Delta t)^3),\n$$\n\nand\n\n$$\nv_{i+1} = v_i+\\frac{(\\Delta t)}{2}\\left(a_{i+1}+a_{i}\\right)+O((\\Delta t)^3).\n$$\n\nNote well that the term $a_{i+1}$ depends on the position at $x_{i+1}$. This means that you need to calculate \nthe position at the updated time $t_{i+1}$ before the computing the next velocity. Note also that the derivative of the velocity at the time\n$t_i$ used in the updating of the position can be reused in the calculation of the velocity update as well.\n\n## Adding the Velocity-Verlet Method\n\nWe can now easily add the Verlet method to our original code as\n\n\n```\nDeltaT = 0.01\n#set up arrays \ntfinal = 10 # in years\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and x\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions as compact 2-dimensional arrays\nr0 = np.array([1.0,0.0])\nv0 = np.array([0.0,2*pi])\nr[0] = r0\nv[0] = v0\nFourpi2 = 4*pi*pi\n# Start integrating using the Velocity-Verlet method\nfor i in range(n-1):\n # Set up forces, air resistance FD, note now that we need the norm of the vecto\n # Here you could have defined your own function for this\n rabs = sqrt(sum(r[i]*r[i]))\n a = -Fourpi2*r[i]/(rabs**3)\n # update velocity, time and position using the Velocity-Verlet method\n r[i+1] = r[i] + DeltaT*v[i]+0.5*(DeltaT**2)*a\n rabs = sqrt(sum(r[i+1]*r[i+1]))\n anew = -4*(pi**2)*r[i+1]/(rabs**3)\n v[i+1] = v[i] + 0.5*DeltaT*(a+anew)\n t[i+1] = t[i] + DeltaT\n# Plot position as function of time \nfig, ax = plt.subplots()\nax.set_ylabel('y[AU]')\nax.set_xlabel('x[AU]')\nax.plot(r[:,0], r[:,1])\nfig.tight_layout()\nsave_fig(\"EarthSunVV\")\nplt.show()\n```\n\nYou can easily generalize the calculation of the forces by defining a function\nwhich takes in as input the various variables. We leave this as a challenge to you.\n\n## Hints for exercises 2 and 3\n\n**Taylor exercise 3.11:**\n\nThis exercise is discussed in Taylor's chapter 3.2.\n\nConsider the rocket of mass $M$ moving with velocity $v$. After a\nbrief instant, the velocity of the rocket is $v+\\Delta v$ and the mass\nis $M-\\Delta M$. Momentum conservation gives\n\n$$\n\\begin{eqnarray*}\nMv&=&(M-\\Delta M)(v+\\Delta v)+\\Delta M(v-v_e)\\\\\n0&=&-\\Delta Mv+M\\Delta v+\\Delta M(v-v_e),\\\\\n0&=&M\\Delta v-\\Delta Mv_e.\n\\end{eqnarray*}\n$$\n\n## Exercise 2\n\nIn the second step we ignored the term $\\Delta M\\Delta v$ since we\ncan assume it is small. The last equation gives\n\n$$\n\\begin{eqnarray}\n\\Delta v&=&\\frac{v_e}{M}\\Delta M,\\\\\n\\nonumber\n\\frac{dv}{dt}dt&=&\\frac{v_e}{M}dM.\n\\end{eqnarray}\n$$\n\nHere we let $\\Delta v\\rightarrow dv$ and $\\Delta M\\rightarrow dM$.\nWe have also assumed that $M(t) = M_0-kt$. \nIntegrating the expression with lower limits $v_0=0$ and $M_0$, one finds\n\n$$\n\\begin{eqnarray*}\nv&=&v_e\\int_{M_0}^M \\frac{dM'}{M'}\\\\\nv&=&v_e\\ln(M/M_0)\\\\\n&=&v_e\\ln[(M_0-k t)/M_0].\n\\end{eqnarray*}\n$$\n\nWe have ignored gravity here. If we add gravity as the external force, we get when integrating an additional terms $-gt$, that is\n\n$$\nv(t)=v_e\\ln[(M_0-k t)/M_0]-gt.\n$$\n\n## Exercise 3, more rockets\n\nThis is a continuation of the previous exercise and most of the relevant background material can be found in Taylor chapter 3.2. \n\nTaking the velocity from the previous exercise and integrating over time we find the height\n\n$$\ny(t) = y(t_0=0)+\\int_0^tv(t')dt'.\n$$\n\nYou need to insert $v(t)$ from the previous exercise\n\nTo do the integral over time we recall that $M(t)=M_0-\\Delta M t$. We assumed that $\\Delta M=k$ is a constant.\nWe use that $M_0-M=kt$ and assume that mass decreases by a constant $k$ times time $t$.\n\n## Some more manipulations which have to be done\n\nWe will need to compute an integral which goes like\n\n$$\n\\int_0^t \\ln{M(t')}dt' = \\int_0^t \\ln{(M_0-kt')}dt'.\n$$\n\nand defining the variable $u=M_0-kt'$, with $du=-kdt'$ and the new limits $M_0$ when $t=0$ and $M_0-kt$ when time is equal to $t$, we have\n\n$$\n\\int_0^t \\ln{M(t')}dt' = \\int_0^t \\ln{(M_0-kt')}dt'=-\\frac{1}{k}\\int_{M_0}^{M_0-kt} \\ln{(u)}du=-\\frac{1}{k}\\left[u\\ln{(u)}-u\\right]_{M_0}^{M_0-kt}.\n$$\n", "meta": {"hexsha": "c290fbba10505986c17ab4efa3c79ff23576d9dd", "size": 49102, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/week7/ipynb/week7.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/pub/week7/ipynb/week7.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/pub/week7/ipynb/week7.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.7008784096, "max_line_length": 271, "alphanum_fraction": 0.5181662661, "converted": true, "num_tokens": 7320, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3849121444839335, "lm_q2_score": 0.3073580295544412, "lm_q1q2_score": 0.11830583828015617}}
{"text": "```python\nfrom IPython.core.display import HTML, Image\ncss_file = 'style.css'\nHTML(open(css_file, 'r').read())\n```\n\n\n\n\n\n \n**Answer:**\n \n \nELBO for **EM** for non-Bayesian model:\n\n$$ELBO^{\\text{EM}}(\\theta, \\phi, q(z)) = \\mathbb{E}_{z\\sim q(z)}\\left[\\log\\left(\\frac{p(y, z|\\theta, \\phi)}{q(z)}\\right)\\right] = \\mathbb{E}_{z\\sim q(z)} \\left[\\log \\left(\\frac{P(y|z,\\phi)p(z|\\theta)}{q(z)}\\right)\\right]\n$$\n\nThe ELBO for **Variational Inference** with a mean field variational family, where $\\psi=(\\theta,\\phi,Z)$:\n\n$$ELBO^{\\text{VI}}(\\psi) = \\mathbb{E}_{\\psi \\sim q(\\psi|\\lambda)}\\left[\\log\\left(\\frac{p(\\psi, Y_1, \\ldots, Y_N |a,b))}{q(\\psi | \\lambda)} \\right)\\right] $$\n\nWrite out in terms of $z, y, \\theta, \\phi$\n \n$$\nELBO = \\mathbb{E}_{z, \\phi, \\theta \\sim q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)} \\left[\\log\\left(\\frac{p(y, z, \\theta, \\phi|a, b)}{q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)}\\right)\\right]\n$$\n\n\n\n**The differences and similarities between these two ELBOs:**\n \n**Similarities:**\n 1. They all incorporate an auxilary function $q(z)$ in order to take the gradients.\n 2. Both take an expectation log ratio between joint distribution over distributions that are not that of the observed variable (auxilary distribution $q$ or variational distribution $q$).\n\n**Differences:**\n1. For VI, we introduce an additional parameter $\\lambda$ for the variation family $Q$, and it is maximized using expetctation wrt the variation family.\n2. In EM, $\\phi$ and $\\theta$ are known constants, and produce point estimation; In VI, they are random variables with distribution and we derive posterior over them; Thus in EM, we optimize the ELBO wrt $\\theta$ and $\\phi$ as point estimates; In variational inference, we optimize over the distribution of $\\theta$ and $\\phi$ \n3. The difference between the ELBO and the KL divergence is the log normalizer (i.e. the evidence), which is the quantity that the ELBO bounds. \n4. In VI, we take the expectation over the distribution of a hyperparameter. In EM, we take the expectation over the distribution of the latent variable. \n\n\n**Special Case**:\n \nEM is a special case of ELBO if we use mean-field VI where the variational distributions $q$ are assumed to be point estimations. That is, Let $\\theta^{*}$ and $\\phi^{*}$ be the unknown location of this point mass:\n $$q_{\\theta}(\\theta)=\\delta\\left(\\theta-\\theta^{*}\\right)$$\n $$q_{\\phi}(\\phi)=\\delta\\left(\\phi-\\phi^{*}\\right)$$\n \nVI will minimize a KL divergence, and so when we minimumize over the variational family, it is the E-step of EM; and the further when minimizing over $\\theta^{*}$ is the M-step of EM.\n\n2. **(Comparing ELBOs and KL-divergences)** Recall that the original objective of variational inference is to minimize a KL-divergence, we rewrote the objective to be that of maximizing the ELBO. Why is directly minimizing the KL-divergence in the original objective difficult (be specific about wherein the difficulty lies)? \n\n In the derivation of the E-step of EM, we reframed an maximization of the ELBO problem as a minimization of a KL-divergence problem. In this case, why was the KL-divergence easier to minimize and the ELBO harder to maximize (use the instantiation of the E-step for Gaussian Mixture Models in Lecture 7 to help support your answer)? \n\n In the notes for Lecture 8, we introduce a way to maximize the variational inference ELBO -- through coordinate ascent. In the derivation of the updates for coordinate ascent, there is a place where we reframed an maximization of the ELBO problem as an equivalent minimization of a KL-divergence problem. Write down the exact form of this equivalence (the two expressions are separated in the derivation by a bunch of lines, you'll need to identify both parts that you need). In this case, why was the KL-divergence easier to minimize and the ELBO harder to maximization (use the instantiation of the update for Gaussian Mixture Models in Lecture 8 to help support your answer)?\n\n Based on this analysis, can you draw some general conclusions about when we'd prefer to minimize the KL-divergence versus when we'd prefer to maximize the ELBO?\n\n \n \nIn VI, we are finding a tractable distribution $q$ that best approximate the complex distribution $p$ by minimizing KL divergence.\n \n$$\n\\begin{aligned}\n\\lambda^* &= \\underset{\\lambda}{\\text{argmin}}\\; D_{\\text{KL}}(q(\\psi|\\lambda) \\| p(\\psi|Y_1, \\ldots, Y_N, a, b))) \\\\\n&= \\underset{\\lambda}{\\text{argmin}}\\; \\mathbb{E}_{\\psi \\sim q(\\psi|\\lambda)}\\left[\\log\\left(\\frac{q(\\psi | \\lambda)}{p(\\psi|Y_1, \\ldots, Y_N))}\\right) \\right]\n\\end{aligned}$$\n\nWrite out in terms of $z, y, \\theta, \\phi$\n\n \n$$\n\\underset{\\lambda}{\\min} D_{\\text{KL}}[q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3) \\| p(\\theta, \\phi, z|y, a, b)] = \\underset{\\lambda}{\\min} \\mathbb{E}_{z, \\phi, \\theta \\sim q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)} \\left[\\log \\left( \\frac{q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)}{p(\\theta, \\phi, z|y, a, b)}\\right) \\right]\n$$\n \n\n\nBy Bayes' rule, the denominator in the log ratio\n\n$$\np(\\theta, \\phi, z|y, a, b) = \\frac{p(y, z, \\theta, \\phi| a, b)}{p(y | a, b)} = \\frac{p(y, z, \\theta, \\phi| a, b)}{\\int p(y, z, \\theta, \\phi| a, b) \\mathrm{d}(z, \\theta,\\phi)} \\propto p(y, z, \\theta, \\phi| a, b)\n$$\n\nTherefore\n\\begin{aligned}\nD_{\\text{KL}}[q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3) \\| p(\\theta, \\phi, z|y, a, b)] &= \\mathbb{E}_{z, \\phi, \\theta \\sim q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)} \\left[\\log \\left( \\frac{q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3) p(y | a, b)}{ p(y, z, \\theta, \\phi| a, b)}\\right) \\right]\\\\\n & = \\mathbb{E}_{z, \\phi, \\theta \\sim q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)} \\left[\\log q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3) + \\log p(y | a, b) - \\log p(y, z, \\theta, \\phi| a, b) \\right]\\\\\n \\end{aligned}\n \nBut that $\\log p(y| a, b) = \\int p(y, z, \\theta, \\phi| a, b)\\mathrm{d}(z, \\theta,\\phi) $ involve integration that's intractable to integrate over $(z, \\theta,\\phi)$.\n \nBut with ELBO, \n \n\\begin{aligned}\nELBO &= \\mathbb{E}_{z, \\phi, \\theta \\sim q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)} \\left[\\log\\left(\\frac{p(y, z, \\theta, \\phi|a, b)}{q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)}\\right)\\right]\\\\\n&= \\mathbb{E}_{z, \\phi, \\theta \\sim q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3)} \\left[\\log p(y, z, \\theta, \\phi|a, b) - \\log q(z, \\phi, \\theta |\\lambda_1, \\lambda_2, \\lambda_3) \\right]\n\\end{aligned}\n \nThe term no longer involves $\\log p(y| a, b)$, making it easier to compute.\nThus, directly minimizing the KL-divergence in the original objective is difficult, we used maximizing ELBO.The issue is that the gradient taken is with respect to the parameter $\\psi$ of the distribution of which we are taking the expectation - i.e. we cannot push the gradient into the expectation.\n\nIn the derivation of the E-step of EM, we reframed an maximization of the ELBO problem as a minimization of a KL-divergence problem. In this case, why was the KL-divergence easier to minimize and the ELBO harder to maximize (use the instantiation of the E-step for Gaussian Mixture Models in Lecture 7 to help support your answer)?\n\n\n\n**Why KL-divergence is easier to minimize and the ELBO is harder to maximize in EM:**\n\n1. Theoretically, when KL is minimized, we know the approximated distribution is the same as the true distribution. \n2. Since we already know what one of the distributions are, we can just equate the other distribution to it and be done. Hence, KL divergence is easier to minimize in this situation\n3. Practically, in ELBO, we need to conduct two sets of iterations, one for E-step and another for M step. Also, we only converge to the lower bound, which is not guaranteed to be the true optimized value.\n4. Besides, for the E-step of EM, it is hard to maximize the ELBO with respect to the auxiliary $q$ function due to complex integration and multivariate gradients.\n\nTo be specific, in E-step, \n$$\n\\underset{q}{\\max} ELBO(\\theta^*, \\phi^*, q(z)) = \\underset{q}{\\max} \\mathbb{E}_{z\\sim q(z)}\\left[\\log\\left(\\frac{p(y, z|\\theta^*, \\phi^*)}{q(z)}\\right)\\right]\n$$\n(after M step, we get $\\theta^*, \\phi^*$ as optimized values)\n \nTo get that, we will take gradient of ELBO, that is, $\\nabla \\mathbb{E}_{z\\sim q(z)}\\left[\\log\\left(\\frac{p(y, z|\\theta^*, \\phi^*)}{q(z)}\\right)\\right]$. But taking gradient with respect to the auxiliary $q$ function due to complex integration and multivariate gradients will be very hard.\n \nTherefore, we think about minimize the KL-divergence, as it is easier to minimize KL divergence.\n \n\nIn the notes for Lecture 8, we introduce a way to maximize the variational inference ELBO -- through coordinate ascent. In the derivation of the updates for coordinate ascent, there is a place where we reframed an maximization of the ELBO problem as an equivalent minimization of a KL-divergence problem. Write down the exact form of this equivalence (the two expressions are separated in the derivation by a bunch of lines, you'll need to identify both parts that you need). In this case, why was the KL-divergence easier to minimize and the ELBO harder to maximization (use the instantiation of the update for Gaussian Mixture Models in Lecture 8 to help support your answer)?\n\n\n\n**In coordinate ascent, now why we choose minimizing KL-divergence?**\n\nMaximize ELBO is equivalent to minimize the KL-divergence in coordinate ascent.\n\n$\\underset{\\lambda_i}{\\max}\\mathbb{E}_{\\psi_i \\sim q(\\psi_i|\\lambda_i)}\\left[\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(\\frac{p(\\psi,data)}{q(\\psi|\\lambda)}\\right)\\right]\\right] $\n$\\equiv \\underset{\\lambda_i}{\\min} D_{\\text{KL}}\\left[q(\\psi_i|\\lambda_i)|| z \\exp \\{\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} [\\log p(\\psi_i,data|\\psi_{-i}]\\}\\right]$\n \n \nFor the following, we will use the following notation:\n\n\\begin{aligned}\n\\lambda_{-i} &= [\\lambda_1\\; \\ldots\\; \\lambda_{i-1}\\; \\lambda_{i+1}\\; \\ldots\\; \\lambda_{I}]\\\\\n\\psi_{-i} &= [\\psi_1\\; \\ldots\\; \\psi_{i-1}\\; \\psi_{i+1}\\; \\ldots\\; \\psi_{I}]\\\\\nq(\\psi_{-i}|\\lambda_{-i}) &= \\prod_{j\\neq i}q(\\psi_{j}|\\lambda_{j})\\\\\n\\end{aligned}\n \nFrom lecture 10, we have shown that \n $$\\mathbb{E}_{\\psi \\sim q(\\psi|\\lambda)}[\\ldots] = \\mathbb{E}_{\\psi_i \\sim q(\\psi_i|\\lambda_i)}\\left[\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})}[\\ldots] \\right]$$\n \n \nand the exact form of the equivalence:\n \n\n\\begin{aligned}\n\\underset{\\lambda_i}{\\max} ELBO(\\lambda) &= \\underset{\\lambda_i}{\\max} \\mathbb{E}_{\\psi_i \\sim q(\\psi_i|\\lambda_i)}\\left[\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(\\frac{p(Y_1, \\ldots, Y_N, \\psi_i | \\psi_{-i})}{q(\\psi_{i}|\\lambda_{i})} \\right)\\right]\\right]\\\\\n&= \\underset{\\lambda_i}{\\min}D_{\\text{KL}} \\left[ q(\\psi_{i}|\\lambda_{i})\\| \\mathcal{Z}\\exp\\left\\{\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(p(Y_1, \\ldots, Y_N, \\psi_i | \\psi_{-i}) \\right)\\right]\\right\\}\\right].\n\\end{aligned}\n\nAs the last set of questions, if we set $q(\\psi_{i}|\\lambda_{i})$ equal to $\\mathcal{Z}\\exp\\left\\{\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(p(Y_1, \\ldots, Y_N, \\psi_i | \\psi_{-i}) \\right)\\right]\\right\\}$, we can solve the optimization. This will be easier than if we compute the gradient of of $ELBO$. In Gaussian Mixture models, in lec10 derivation, terms with subscript $-i$ will become constant after iterations.\n\n\nBased on this analysis, can you draw some general conclusions about when we'd prefer to minimize the KL-divergence versus when we'd prefer to maximize the ELBO?\n\n\n \n**Conclusion**\n\n1. Look for complexity of mathematics when implementing the right method\n\n2. We use KL divergence when we know one of the distributions exactly - then it is clear that the to minimize the divergence we just have to equate the other distribution to the other distribution\n\n3. When the form of probability $P(A|B)$ is known and not intractible, we can use KL divergence minimization. When $P(A|B)$ is unknown and hard to compute, we can choose to work with ELBO, but this still require the joint of $A$ and $B$ to be tractable. \n\n3. **(The Mean Field Assumption and Coordinate Ascent)** Describe exactly when and how the mean field assumption is used in the derivation of the coordinate ascent updates. \n \n**Answer:**\n\n\nWe assume that the joint $q(\\psi)$ factorizes completely over each dimension of $\\psi$, i.e. $q(\\psi)= \\prod_{i=1}^I q(\\psi_i | \\lambda_i)$. This is called the ***mean field assumption***. This assumes that each dimension of $q(\\psi)$ is independent from the others, which may or may not be valid, but it helps to simplify the expression of $q(\\psi)$, making it easier to find the ELBO. Thus it is a design choice to make, and it could also go wrong with this design choice.\n\nThe coordinate ascent algorithm maximize an objective function ELBO by iteractively maximizing over one dimension, while holding other dimension constant. That's why it requires us to be able to use mean field assumption and factorize $q(\\psi)$ into individual pieces.\n \nTo use mean field assumption, we will maximize the $ELBO$ by following steps in the derivation of the coordinate ascent updates.\n\n1. Use the mean-field assumption to break up the expectation $\\mathbb{E}_{\\psi \\sim q(\\psi|\\lambda)}$ into an iterated expectation $\\mathbb{E}_{\\psi_i \\sim q(\\psi_i|\\lambda_i)}\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})}$\n2. We will rewrite the outer expectation $\\mathbb{E}_{\\psi_i \\sim q(\\psi_i|\\lambda_i)}$ as a negative KL-divergence\n3. We will then maximize the negative KL-divergence by setting the two arguments of the divergence equal to each other\n\n\n\n4. **(Generalizability of CAVI)** Summarize what kind of derivations/math is needed in order instantiate Coordinate Ascent Variational Inference (CAVI) for a given new model (look at what we did for Gaussian Mixture Models in Lecture 8 and predict what you'd need to do for a new model). Based on this, discuss the potential draw backs of using CAVI for Bayesian inference in general. What do these draw backs imply about the practicality of variational inference as an inference method?\n \n**Answer:**\n \nWe see that \n\n$$\nD_{\\text{KL}} \\left[ q(\\psi_{i}|\\lambda_{i})\\| \\mathcal{Z}\\exp\\left\\{\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(p(Y_1, \\ldots, Y_N, \\psi_i | \\psi_{-i}) \\right)\\right]\\right\\}\\right]\n$$\n\nis minimized when \n\n$$\n q(\\psi_{i}|\\lambda_{i})\\propto \\exp\\left\\{\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(p(Y_1, \\ldots, Y_N, \\psi_i | \\psi_{-i}) \\right)\\right]\\right\\}.\n$$\n\nThis is also exactly where the ELBO is maximized.\n\n\n**Derivations/Math needed:**\n\n1. We need mean field assumption to derive the variational distribution of each variable or parameter independently and separately.\n2. For each i, we need to set $q(\\psi_{i}|\\lambda_{i})$ equal to $\\mathcal{Z}\\exp\\left\\{\\mathbb{E}_{\\psi_{-i} \\sim q(\\psi_{-i}|\\lambda_{-i})} \\left[\\log \\left(p(Y_1, \\ldots, Y_N, \\psi_i | \\psi_{-i}) \\right)\\right]\\right\\}$ to solve for ELBO iteractively in CAVI.\n3. We need lengthy algebraic manipulation to expand the expectation term\n4. Computational wise also expensive, need to iterate through $\\lambda_i$\n\n\n**Drawbacks**\n1. It may never converge\n2. We will never be able to capture the full complexity of target distribution by sampling from posterior q\n3. We are trading off fidelity for computational tracibility.\n4. Computational heavy, we need to derive different $q(\\psi_{i}|\\lambda_{i})$ at each iteration for different models.\n5. We need conduct lengthy posterior derivations for each latent variable / paramter which may result in intractable posterior distributions\n\n\n**Particability**\n\nIt is still practical but it may be need some mathematical derivations when iteractively minimize KL. In each step, variety of complex algorithms and sampling methods can be used.\n \n \n\n5. **(Generalizability of EM)** Summarize what kind of derivations/math is needed in order instantiate Expectation Maximization (EM) for a given new model (look at what we did for Gaussian Mixture Models in Lecture 9 and predict what you'd need to do for a new model). Based on this, discuss the potential draw backs of using EM for MLE inference in general. What do these draw backs imply about the practicality of EM as an inference method?\n\n\n \n\n**Answer:**\n \n0. **Initialization:** Pick $\\theta_0$, $\\phi_0$.\n1. Repeat $i=1, \\ldots, I$ times:\n\n **E-Step:** \n$$q_{\\text{new}}(Z_n) = \\underset{q}{\\mathrm{argmax}}\\; ELBO(\\theta_{\\text{old}}, \\phi_{\\text{old}}, q) = p(Z_n|Y_n, \\theta_{\\text{old}}, \\phi_{\\text{old}})$$\n\n **M-Step:** \n \\begin{aligned}\n \\theta_{\\text{new}}, \\phi_{\\text{new}} &= \\underset{\\theta, \\phi}{\\mathrm{argmax}}\\; ELBO(\\theta, \\phi, q_{\\text{new}})\\\\\n &= \\underset{\\theta, \\phi}{\\mathrm{argmax}}\\; \\sum_{n=1}^N\\mathbb{E}_{Z_n\\sim p(Z_n|Y_n, \\theta_{\\text{old}}, \\phi_{\\text{old}})}\\left[\\log \\left( p(y_n, Z_n | \\phi, \\theta\\right) \\right].\n\\end{aligned}\n\n \nFor the **E-Step**, we just simply calculate the conditional distribution of each $Z_n|Y_n, \\theta_\\text{old}, \\phi_\\text{old}$. It is usually obtained by employing Bayesian Rule. (The $Z_n$ here is of discrete type.) \n \n\n**Answer:**\n\nThe countries with highest and lowest cancer rate are those countries with low populations, located on the left side of the scatterplot. Both the highest rates mortality and the lowest rates mortality counties are not the points have large population.\n \nThis could happen due to drawbacks of MLE estimates, it tends to overfit when data is scarce. Countries with less population may only have few data points, thus resulting in overfitting, exaggerated effect and extreme pct_mortality rate.\n\n2. **(Empirical Bayes)** Using Empirical Bayes and moment matching, choose values for the hyperparameters $\\alpha, \\beta$ based on your data. Use these values of $\\alpha$ and $\\beta$ to obtain posterior distributions for each county.\n\n***Hint:*** You'll first need to derive the fact that the ***evidence*** for a Poisson-Gamma model has a Negative Binomial distribution.\n \nFrom the last homework, we first derived $p(\\theta_j | \\theta_{-j}, y, \\alpha, \\beta)= Ga(\\theta_j; \\alpha+y_j, 5n_j+\\beta)$ \n\n**Part I.** By Bayes' Theorm,\n$$\n\\begin{align}\np(\\theta_j | \\theta_{-j}, y, \\alpha, \\beta) &= \\frac{p(\\theta| y, \\alpha, \\beta)}{p( \\theta_{-j}| y, \\alpha, \\beta)} \\propto p(\\theta| y, \\alpha, \\beta) = \\prod_{i=1}^N p(\\theta_i|y, \\alpha, \\beta) \\\\\n\\end{align}\n$$\n\nBy holding $\\theta_{-j}, y, \\alpha, \\beta$ constant, we could see that $p(\\theta| y, \\alpha, \\beta)$ only depends on $$p(\\theta_j| y_j, \\alpha, \\beta) =\\frac{ p(\\theta_j, y_j|\\alpha, \\beta)}{p(\\alpha, \\beta)}\\propto p(\\theta_j, y_j|\\alpha, \\beta) = p(y_j|\\theta_j, \\alpha, \\beta)p(\\theta_j|\\alpha,\\beta)$$.\n\nThen, we could compute the joint distribution of $p(\\theta_j, y_j|\\alpha, \\beta)$ as the product of the two distributions.\n \n$$\n\\begin{align}\np(\\theta_j, y_j|\\alpha, \\beta) &=p(y_j|\\theta_j, \\alpha, \\beta)p(\\theta_j|\\alpha,\\beta)\\\\ &= Poisson(y_j; 5\\cdot n_j \\cdot \\theta_j)\\cdot(\\theta_j; \\alpha, \\beta)\\\\\n&= \\frac{(5n_j\\theta_j)^{y_j}e^{-5n_j\\theta_j}}{y_j!}\\cdot\\frac{\\beta^\\alpha\\theta_j^{\\alpha-1}e^{-\\beta\\theta_j}}{\\Gamma(\\alpha)}\\\\\n&\\propto \\theta_j^{\\alpha+y_j-1}e^{-(5n_j+\\beta)\\theta_j}\\\\\n&= Ga(\\theta_j; \\alpha+y_j, 5n_j+\\beta)\n\\end{align}\n$$\nQ.E.D.\n \nThus, we derived that $p(\\theta_j | \\theta_{-j}, y, \\alpha, \\beta)= Ga(\\theta_j; \\alpha+y_j, 5n_j+\\beta)$ \n\n\n\nThen we prove $p(y_j) = NB\\left(r, p\\right)$ using the fact: $\\Gamma(\\alpha) = (\\alpha - 1)!$\n\\begin{aligned}\np(y_j) &= \\frac{p(y_j | \\theta_j) p(\\theta_j)}{p(\\theta_j | y_j)}\\\\\n &= \\frac{Poiss(y_j; 5 \\cdot n_j \\cdot \\theta_j) Ga(\\theta_j; \\alpha, \\beta)}{Ga(\\alpha + y_j, 5 n_j + \\beta)}\\\\\n&= \\frac{\\frac{1}{y_j!} Exp[5 \\cdot n_j \\cdot \\theta_j] \\frac{\\beta^\\alpha}{\\Gamma(\\alpha)} \\theta_j^{\\alpha - 1} Exp[-\\beta\\theta_j]}{\\frac{\\left(5 n_j + \\beta\\right)^{\\left( \\alpha + y_j\\right)}}{\\Gamma\\left(\\alpha + y_j\\right)} \\theta_j^{\\alpha + y_j - 1} Exp[-\\left(5 n_j + \\beta\\right) \\theta_j]}\\\\\n&= \\frac{\\beta^\\alpha\\Gamma\\left(\\alpha + y_j\\right) \\left(5 \\cdot n_j\\right)^{y_j} \\theta_j^{\\alpha + y_j - 1}Exp[-\\left(5 \\cdot n_j + \\beta\\right)\\theta_j]}{y_j!\\Gamma(\\alpha) \\left(5 n_j + \\beta\\right)^{\\left( \\alpha + y_j\\right)}\\theta_j^{\\alpha + y_j - 1} Exp[-\\left(5 n_j + \\beta\\right) \\theta_j]}\\\\\n&= \\frac{\\beta^\\alpha\\Gamma\\left(\\alpha + y_j\\right) \\left(5 \\cdot n_j\\right)^{y_j}}{y_j!\\Gamma(\\alpha) \\left(5 n_j + \\beta\\right)^{\\left( \\alpha + y_j\\right)}}\\\\\n&= \\frac{\\Gamma\\left(\\alpha + y_j\\right)}{y_j!\\Gamma(\\alpha)}\\frac{\\beta^\\alpha}{\\left(5 n_j + \\beta\\right)^{\\alpha}} \\frac{\\left(5 \\cdot n_j\\right)^{y_j}}{\\left(5 n_j + \\beta\\right)^{y_j}}\\\\\n&= \\frac{\\Gamma\\left((\\alpha + y_j - 1) + 1\\right)}{y_j!\\Gamma(\\alpha)} \\left( \\frac{\\beta}{5 n_j + \\beta}\\right)^\\alpha \\left( \\frac{5 \\cdot n_j}{5 n_j + \\beta}\\right)^{y_j}\\\\\n&= \\frac{(\\alpha + y_j - 1)!}{y_j!\\Gamma(\\alpha)}\\left( \\frac{\\beta}{5 n_j + \\beta}\\right)^\\alpha \\left( \\frac{5 \\cdot n_j}{5 n_j + \\beta}\\right)^{y_j}\\\\\n&= \\frac{(\\alpha + y_j - 1)!}{y_j!(\\alpha - 1)!}\\left( \\frac{\\beta}{5 n_j + \\beta}\\right)^\\alpha \\left( \\frac{5 \\cdot n_j}{5 n_j + \\beta}\\right)^{y_j}\\\\\n&= \\binom{\\alpha + y_j - 1}{y_j}\\left( \\frac{\\beta}{5 n_j + \\beta}\\right)^\\alpha \\left( \\frac{5 \\cdot n_j}{5 n_j + \\beta}\\right)^{y_j}\\\\\n&= NB\\left(\\alpha, \\frac{5 n_j}{ 5 n_j + \\beta}\\right)\n\\end{aligned}\n\n \nThe theoritical mean and variance for negative binomial distribution:\n\\begin{align}\n\\mathbb{E}\\left[y_j\\right] &= \\frac{\\alpha5n_j}{\\beta} \\\\\n\\text{Var}\\left[y_j\\right] &= \\frac{\\alpha 5 n_j (5n_j+\\beta)}{\\beta^2}\n\\end{align}\n\nThen, the empirical counterparts adjusted by the population of each county:\n\\begin{aligned}\n\\widehat{\\mathbb{E}}\\left[\\frac{y_j}{n_j}\\right] &= \\frac{5\\alpha}{\\beta}\\\\\n\\widehat{\\text{Var}}\\left[\\frac{y_j}{n_j}\\right] &= \\frac{5 \\alpha (5 n_j+\\beta)}{n_j\\beta^2} = \\frac{5 \\alpha(5\\bar{n}+\\beta)}{\\bar{n}\\beta^2}\n\\end{aligned}\nFor the variance case we shall put population mean instead of $n_j$\n \nSolve and get:\n\\begin{aligned}\n\\alpha &= \\frac{\\bar{pop}\\widehat{\\mathbb{E}}^2 }{\\bar{pop} \\widehat{\\text{Var}} - \\widehat{\\mathbb{E}}} \\\\ \\\\\n\\beta &= \\frac{5 \\bar{pop} \\widehat{ \\mathbb{E}} }{\\bar{pop}\\widehat{\\text{Var}} - \\widehat{\\mathbb{E}}}\n\\end{aligned}\n \n \n\n\n```python\ne_hat = np.mean(y/n)\nvar_hat = np.var(y/n)\npop_mean = np.mean(n)\n\nalpha = pop_mean*e_hat**2/(pop_mean*var_hat - e_hat)\nbeta = 5*pop_mean*e_hat/(pop_mean*var_hat - e_hat)\n\nprint(\"empirical cancer rate population adjusted mean: = {}\".format(e_hat))\nprint(\"empirical cancer rate population adjusted var = {}\".format(var_hat))\nprint(\"empirical population mean = {}\".format(pop_mean))\nprint('')\n\nprint(\"alpha = {}\".format(alpha))\nprint(\"beta = {}\".format(beta))\n\n```\n\n empirical cancer rate population adjusted mean: = 5.786552354108626e-05\n empirical cancer rate population adjusted var = 2.527523010812238e-09\n empirical population mean = 160512.41021522647\n \n alpha = 1.5451734918796929\n beta = 133514.17193888978\n\n\n\n\n\nKnowing from the derivation that $$\\theta_i|y_i \\sim Ga(\\alpha + y_j, 5 n_j + \\beta)$$\nwe can sample $\\theta$ from $Ga(1.5451734918796929 + y_j, 5 n_j + 133514.17193888978)$ and compute the mean or mode from the samples:\n\n\n```python\n# update estimate\nthetas = []\nfor i in range(5000):\n thetas.append(np.random.gamma(alpha + df['dc'].values, 1. / (beta + 5 * n)))\nthetas = np.array(thetas)\nthetas_mean = np.mean(thetas, axis=0)\n```\n\n3. **(Posterior Means)** Produce a scatter plot of the raw cancer rates (pct mortality) vs the county population size (in log scale). Highlight the top 300 raw cancer rates in red. Highlight the bottom 300 raw cancer rates in blue. Finally, on the same plot again, scatter plot the posterior mean cancer rate estimates vs the county population size, highlight these means in green. \n\n Using the scatter plot, explain why using the posterior means (from our model) to estimate cancer rates is preferable to studying the raw rates themselves.\n\n\n```python\nscatter_plot_cancer_rates(df, estimates=thetas_mean)\nplt.legend()\nplt.show()\n```\n\n\n \n\n**Answer:**\n\nComparing to previous plot, we can observe that the posterior means to estimate cancer rate produce less extreme pct_mortality result. For countries with low population, it no longer has extreme high or low cancer rate, instead, they trend towards population average. It is preferable because the mean estimate mitigates the effect of small population size and overfitting problem.\n\n## Part II: Hierarchical Bayes\nRather than choosing fixed constants for the hyperparameters $\\alpha, \\beta$, following the Bayesian philosophy, we typically put additional priors on quantities of which we are uncertain. That is, we model the kidney cancer rates using a ***hierarchical model***:\n\n\\begin{aligned}\ny_j| \\theta_j &\\sim Poisson(5 \\cdot n_j \\cdot \\theta_j), \\quad j = 1, \\ldots, N\\\\\n\\theta_j | \\alpha, \\beta &\\sim Ga(\\alpha, \\beta), \\quad j = 1, \\ldots, N\\\\\n\\alpha &\\sim Ga(a, b)\\\\\n\\beta &\\sim Ga(c, d)\n\\end{aligned}\nwhere $a, b, c, d$ are hyperparameters. \n\n1. **(Posterior Marginal Means)** Produce a scatter plot of the raw cancer rates (pct mortality) vs the county population size (in log scale). Highlight the top 300 raw cancer rates in red. Highlight the bottom 300 raw cancer rates in blue. Finally, on the same plot again, scatter plot the mean of the posterior marginal distribution over $\\theta_j$, i.e. $p(\\theta_j|y_1, \\ldots, y_N)$, vs the county population size (in log scale), highlight these means in orange. \n\n You should use `pymc3` to sample from the posterior. Compare `pymc3`'s sampler with your sampler from the previous homework, what is the difference (if any) in the performance of these samplers?:3: FutureWarning: In v4.0, pm.sample will return an `arviz.InferenceData` object instead of a `MultiTrace` by default. You can pass return_inferencedata=True or return_inferencedata=False to be safe and silence this warning.\n trace = pm.sample(1000, tune=1000, target_accept = 0.9)\n Auto-assigning NUTS sampler...\n Initializing NUTS using jitter+adapt_diag...\n Multiprocess sampling (4 chains in 4 jobs)\n NUTS: [theta, beta, alpha]\n\n\n\n\n\n \n
\n 100.00% [8000/8000 00:34<00:00 Sampling 4 chains, 0 divergences]\n
\n \n**Interpretation**:\n\nFrom this graph, we could observe that mean estimate from the posterior marginal distribution that sampled by hierarchical model using pymc3 now shrink to population mean, with more shrinkage for low population counties. \n\n\n```python\nfig, ax = plt.subplots(1, 2, figsize=(30, 5))\n#N = len(trace['theta'].T[county_1])\nalpha_trace = trace['alpha'][int(burn_in * N)::thinning]\nbeta_trace = trace['beta'][int(burn_in * N)::thinning]\n\nax[0].plot(range(len(alpha_trace)), alpha_trace, color='gray')\nax[0].set_title('Trace Plot for Alphas')\nax[0].set_ylabel('alpha')\nax[1].plot(range(len(beta_trace)), beta_trace, color='gray')\nax[1].set_title('Trace Plot for Betas')\nax[1].set_ylabel('beta')\nplt.show()\n```\n\n\n```python\n#select the county to visualize the traceplot for theta\n#same countries to compare with last homework\ncounty_1 = 0\ncounty_2 = 1\n\n#plot the traceplots for one theta and alpha and beta\nfig, ax = plt.subplots(1, 2, figsize=(30, 5))\nN = len(trace['theta'].T[county_1])\ntheta_trace = trace['theta'][int(burn_in * N)::thinning].T[county_1]\nax[0].plot(range(len(theta_trace)), theta_trace, color='gray', alpha=0.5)\nax[0].set_title('trace plot for theta_{}'.format(county_1))\n\ntheta_trace = trace['theta'][int(burn_in * N)::thinning].T[county_2]\nax[1].plot(range(len(theta_trace)), theta_trace, color='gray', alpha=0.5)\nax[1].set_title('trace plot for theta_{}'.format(county_2))\n```\n\n\n \n**Interpretation**:\n\nComparing to last homework where visual graph show clearly evidence of non-convergence of $\\alpha$ and $\\beta$ after multiple rounds of Gibbs-MH sampling, this graph shows a considerable level of convergence, and looks better than last time.\n \nI selected two counties that is the same as last time in homework 4 and compare for posterior marginal distribution of $\\theta$. It seems they have converged and are fluctuating within a small range too. It seems this sampler perform better than our Gibbs MH sampler implemented. This could be due to a better choice of proposal alpha beta distribution and hyperparameters, and a more complex implementation of sampling method.\n\n2. **(Hierarchical Bayes vs Empirical Bayes)** Compare the shrinkage of the posterior marginal means of the hierarchical model to the shrinkage of the posterior means from the Bayesian model with empirical Bayes estimates for $\\alpha, \\beta$. What is the difference in shrinkage between the full hierarchical model and the Bayesian model with empirical Bayes?\n\n\n```python\nscatter_plot_cancer_rates(df, estimates=thetas_mean)\nplt.title(\"pct_mortality vs pop in kcancer dataset (empirical bayes)\")\nplt.legend()\nplt.show()\n\nscatter_plot_cancer_rates_orange(df, estimates = pymc_post_mean)\nplt.title(\"pct_mortality vs pop in kcancer dataset (hierachical bayes)\")\nplt.legend()\nplt.show()\n```\n\n\n \n**Interpretation**:\n \nComparing two plots with green shrinkage (empirical bayes) and the orange shrinkage (hierachical bayes) of mean estimates, we could observe a larger shrinkage for the counties with least population in hierachical bayes estimations than empirical bayes estimates.\n \nThe hierarchy model pulls together the pct_mortality drastically for counties with small population size, while empirical bayes still shows strips of trends of pct_mortality that are not shrinked to a population mean for counties with small population size. The variations observed in hierachial bayes estimate are that there exists higher variance in the middle parts of population size. However, this doesn't seem to correlated with population size, nor due to the result of overfitting. It could be random variation instead of systematic variation. With hierachical bayes we can safely conclude that the cancer rate is almost the same for all counties regardless of population size, which also makes much more sense in real life.\n\n## Part III: Broader Impact Analysis\n\nStarting in 2020, major machine learning conferences are beginning to ask authors as well as reviewers to explicitly consider the broader impact of new machine learning methods. To properly evaluate the potential good or harm that a piece of technology (AI or not) can do to the general public, we need to be aware that no technology is deployed in ideal conditions or in perfectly neutral contexts. In order to assess the potential broader impact of technology, we need to analyze the social systems/institutions of which these technologies will become a part.\n\nTo help you analyze the broader impact of your technology, begin by considering the following questions:\n\nI. Identify the relevant socio-technical systems\n - In what social, political, economic system could the tech be deployed?\n - How would the tech be used in these systems (what role will it take in the decision making processes)?\n \n**Answers**:\n \nWhen put this model for kidney cancer and health care resources, we are sampling and estimating $\\theta$, which is the underlying kidney cancer rate for that county. The other components of the decision system in which the model will deployed will be citizens living in that county, patients receiving kidney cancer related healthcare or treatments, government, resources department, hospital, doctors etc.\n \nEnd user will be government, resources department, hospital, doctors etc;\nAffected communities will be citizens living in that county, patients receiving kidney cancer related healthcare or treatments.\n \nWhether it is more preferable to use a hiearchical model, an MLE model, a Bayesian model with hand-picked priors, or here, an empirical model depends more on a downstream task. \n \n \n* Real life advantages:\n * Easy to implement and compute, more tractable to implement the inference algorithm for empirical Bayesian model compared with an hierarchical Bayesian.\n * As we only need to look at evidence moments, it is more easy to understand and interpret to end user and community.\n * We don't need to hand pick prior that incorporate our prior belief if we have no experience in the field. It avoids the risk of a poor choice of prior.\n * It will converge when data size gets larger.\n \n \n \n**Drawbacks of implementing an empirical Bayesian model compared with an hierarchical Bayesian model:**\n * It may heavily depend on data quality and data size. Unlike how little poor choice of hierarchical model was, it has less effect on estimatation $\\theta$. However, the data quality in empirical model heavily decides our estimation.\n * It may not converge, or the mean estimate we observed may not shrink to a range. There's still overfitting in low population or small size data points. Those data points are unable to borrow statistical power from data points with more populations like in hierarchial models.\n * If not converged or shrink to a population mean, this will leads to difficulty for government and agency to figure out where to fund, which county has higher kidney cancer rate. \n * The needs for evidence and samples will leads to questions about where to put clinical trials, how many trials shall we obtain in terms of data points; Healthcare data points is unlike other data points to collect, it needs a lot of resource and invests to obtain.\n * If we overestimate the cancer rate, it's not serving anything or communities; it's not serving people who needed; The actual death rate is not that high; If we underestimate the cancer rate, we might under devote health care resources to needed people and county;\n * We might also missing out envrionment factors that affect the rate.\n * The algorithm may not always be tractable. If the population is non-conjugate prior, then it would be hard to sample from population to get needed data points for empirical bayesian model.\n * It's hard to diagnose issue within the data after we obtain the estimation.\n \n \n\n \n\n2. **(Mitigation of Potential Negative Impacts)** Based on your answers for the previous question and your broader impact analysis from HW#4, what information would the model designer/engineer need to disclose to the end-users to mitigate potentially negative impacts?\n\n **Hint:** consider how your end-user would be able to validate the model (how would they know if the model is working or has ceased to work once it has been deployed), how should the end-user choose between implementing a hiearchical Bayesian model or an empirical Bayesian model, how could the end-user identify and mitigate negative impacts (if they occur).\n\n\n \n**Answers**:\n \nThe potential downside and negative impacts, as mentioned briefly above, could be that \n- If we overestimate the cancer rate, it's not serving anything or communities; it's not serving people who needed; The actual death rate is not that high; If we underestimate the cancer rate, we might under devote health care resources to needed people and county;\n- If there exists systematic inequality, the model are helping to exaggerated it. For example, in rural counties they might already have low income, bad infrastructure, and a bad sampling model will help to systematically exaggerating the circumstance.\n \nTo mitigate negative impacts, end users should be able to validate the models by convergence check (traceplots etc), cross validation with human experts and experienced professionals. They should also treat end result with care and involve human decison making instead of fully taking computed results.\n\nFor patients and other affected communities, end users should give full disclosure of how model is being used and deployed, giving advice per treatment. Besides, other environmental factors should also be reviewed before making decision.\n \nThe next thing we would like to consider is that if any of these mistakes or negative impacts happening at random?\n\n- Data inbalance in healthcare is a huge problem (For example, gender data inequality, in many cases there's seldom woman data points, which is regarded as a commonly underpresented group.) The model may exaggerate this problem, and also overfit to one sub-population while be harmful to predictions in other subpopulation. \n- Model for these data are qualitatively different. Studies in man doesn't generalize to women.\n- For subgroups that are previously undersample, we will likely to remove them, as they look like outliers (Small data inside big data problem).\n- Thus, maybe consider using a mixture of several models to compare and cross check for estimation, and also allow small data size points to borrow statistical power from large data size points like what hierarchial model does would be a preferable choice.\n", "meta": {"hexsha": "780d7d80971cdc238a58e1a7aa03b2b9f99da7bd", "size": 571057, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "HW5/AM207_HW5_jiahuitang.ipynb", "max_stars_repo_name": "TangJiahui/AM207-Stochastic-Optimization", "max_stars_repo_head_hexsha": "4288efeb7c017d8d7fa1432ef0b4fcb2f1d42f1d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "HW5/AM207_HW5_jiahuitang.ipynb", "max_issues_repo_name": "TangJiahui/AM207-Stochastic-Optimization", "max_issues_repo_head_hexsha": "4288efeb7c017d8d7fa1432ef0b4fcb2f1d42f1d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "HW5/AM207_HW5_jiahuitang.ipynb", "max_forks_repo_name": "TangJiahui/AM207-Stochastic-Optimization", "max_forks_repo_head_hexsha": "4288efeb7c017d8d7fa1432ef0b4fcb2f1d42f1d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 458.3121990369, "max_line_length": 119360, "alphanum_fraction": 0.9266588099, "converted": true, "num_tokens": 13999, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.35220178204788966, "lm_q2_score": 0.3345894279828469, "lm_q1q2_score": 0.11784299278994272}}
{"text": "```python\n%matplotlib inline\n\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nplt.rcParams[\"figure.figsize\"] = (12, 9)\nplt.rcParams[\"font.size\"] = 18\n```\n\n# Radioactivity\n\nLearning Objectives:\n\n- Explain how radioactivity was discovered\n- Explain the nuclear physical reason for radioactive decay\n- List the sources of natural and man made radiation\n- Read and understand a decay diagram\n- Calculate Q values for various types of decay\n- Describe the physics of various types of decay\n- State the radioactive decay law\n- Derive the radioactive decay law\n- Understand how incorporating sources impacts decay calcuations\n- Calculate decay with production for simple cases\n\n## Discovery of Radioactivity\n- Radioactivity was first discovered in 1896 by Henri Becquerel, while working on phosphorescent materials.\n- These materials glow in the dark after exposure to light, and he thought that the glow produced in cathode ray tubes by X-rays might be connected with phosphorescence.\n- He wrapped a photographic plate in black paper and placed various phosphorescent minerals on it.\n- All results were negative until he used uranium salts.\n\n Becquerel in the lab \n\nPhotographic plate made by Henri Becquerel showing effects of exposure to radioactivity. \n\n\n**What is nuclear decay?**\nA spontaneous process where the protons and neutrons in a given nucleus are rearranged into a lower energy state.\nThe transition may involve levels of the same nucleus (gamma emission, internal conversion) or levels of a different nucleus (alpha, beta decay).\n\n**Why do nuclei decay?** A nucleus decays when it is **unstable**. It undergoes decay in order to become more stable (lower energy state).\n\n**Where do the unstable nuclei come from?**\n\n\n## Sources of Radiation\n\n> A chart of the public's exposure to ionizing radiation (displayed below) \n> shows that people generally receive a total annual dose of about 620 millirem. \n> Of this total, natural sources of radiation account for about 50 percent, \n> while man-made sources account for the remaining 50 percent. -- US NRC\n\n\n\n## Natural Sources\n\n\n\n### Terrestrial\n\nUranium, thorium, radium, etc. are all present naturally inside rocks and soil and are part of the four major decay chains. Others are 'primordial.' Primoidal radioactive isotopes include about 20 isotopes that are long lived and not part of any decay chain (K-40, Rubidium-87) Potassium has a quite radioactive isotope, $^{40}K$. (bananas)\n\nEvolution of the earth's radiogenic heat (in the mantle). \n\n### Internal\n\nMostly $^{40}K$ and $^{14}C$ inside your body.\n\n### Cosmic\nCommonly, cosmic radiation includes $^{14}C$, tritium ($^3H$), and others.\n\nCC BY-SA 3.0 , Link
\n\n\n\n\nAir showers ensuing from very-high-energy cosmic rays can enter Earth’s atmosphere from multiple directions. Credit: Simon Swordy/NASA.\n\n\n## Man-Made Radiation\n\nOf approximately 3200 known nuclides:\n- **266** are stable, \n- **65** long-lived radioactive isotopes are found in nature, \n- and the remaining **~2900** have been made by humans.\n\nOne of the heaviest named elements is Livermorium (Z=116), its most stable isotope $^{293}Lv$ has half-life $t_{1/2} = 60 ms$.\n\n\n\n### Types of Decay \n\n\n```python\n# The below IFrame displays Page 121 of your textbook:\n# Shultis, J. K. (2016). Fundamentals of Nuclear Science and Engineering Third Edition, \n# 3rd Edition. [Vitalsource]. Retrieved from https://bookshelf.vitalsource.com/#/books/9781498769303/\n\nfrom IPython.display import IFrame\nIFrame(\"https://bookshelf.vitalsource.com/books/9781498769303/pageid/121\", width=1000, height=1000)\n\n```\n\n\n\n\n\n\n\n\n\n\nAll elements smaller than Z=83 (Bismuth) have at least one stable isotope.\nExceptions: Technetium (Z=43) and Promethium (Z=61).\n\nOnce nucleus gets past a certain size, it is unstable\nThe largest stable nucleus is Pb-208, all isotopes larger than this are unstable\n\nNuclear conservation laws apply. The following are conserved:\n- charge\n- number of nucleons (proton + neutron)\n- total energy (mass + energy)\n- linear momentum (in inertial frame of reference)\n- angular momentum (spin)\n - alternatively: leptons (electrons + neutrinos)\n\n\n```python\n# The below IFrame displays Page 100 of your textbook:\n# Shultis, J. K. (2016). Fundamentals of Nuclear Science and Engineering Third Edition, \n# 3rd Edition. [Vitalsource]. Retrieved from https://bookshelf.vitalsource.com/#/books/9781498769303/\nfrom IPython.display import IFrame\nIFrame(\"https://bookshelf.vitalsource.com/books/9781498769303/pageid/122\", width=1000, height=1000)\n```\n\n\n\n\n\n\n\n\n\n\n## Energetics of Decay\n\n
\n\n\n\n\n## Half Life\n\nAll dynamic processes which decay (or grow) exponentially can be characterized by their half life (or doubling time). In the case of radioactive decay\n\n\\begin{align}\n \\tau_{1/2}&= \\mbox{half-life}\\\\\n &=\\frac{ln(2)}{\\lambda} \\\\\n t &= \\mbox{time elapsed [s]}\\\\\n \\tau_{1/2} &= \\mbox{half-life [s]} \\\\\n\\end{align}\n\n\n\n```python\n# This code converts decay constant to half life\n\ndef half_life(lam):\n return math.log(2)/lam \nlam = 1.0\n\n# This code plots the decay of an isotope for various half lives\nimport numpy as np\ny = np.arange(8.0)\nx = np.arange(8.0)\n\nlives = np.arange(half_life(lam), 9*half_life(lam), half_life(lam))\nfor i, t in enumerate(lives):\n x[i] = float(t)\n y[i] = n_decay(t)\n \n# creates a figure and axes with matplotlib\nfig, ax = plt.subplots()\nscatter = plt.scatter(x, y, color='blue', s=y*20, alpha=0.4) \nax.plot(x, y, color='red') \n\n# adds labels to the plot\nax.set_ylabel('N_i(t)')\nax.set_xlabel('Time')\nax.set_title('N_i')\n\n# adds tooltips\nimport mpld3\nlabels = ['{0}% remaining'.format(i) for i in y]\ntooltip = mpld3.plugins.PointLabelTooltip(scatter, labels=labels)\nmpld3.plugins.connect(fig, tooltip)\n\nmpld3.display()\n```\n\n\n\n\n\n\n\n\n
\n\n\n\n\nAfter n half lives, only $\\frac{1}{2^n}$ of the original sample remain.\n\\begin{align}\nN(n\\tau_{1/2})= \\frac{1}{2^n}N_0\n\\end{align}\n\nIn a sample, $N_0$ has has been reduced to a fraction of $N_0$, $\\epsilon$. How many half lives have passed?\n\n\\begin{align}\nn = \\frac{-ln\\epsilon}{ln2}\n\\end{align}\n\nFinally, the radioactive decay law can be expressed using the half-life:\n\n\\begin{align}\nN(t) = N_0\\left(\\frac{1}{2}\\right)^{t/\\tau_{1/2}}\n\\end{align}\n\n## Decay by competing processes\n\n\\begin{align}\n\\frac{dN(t)}{dt} &= -\\lambda_1N(t) - \\lambda_2N(t) - \\cdots \\lambda_nN(t)\\\\\n &= -\\sum_{i=1}^n \\lambda_iN(t)\\\\\n &\\equiv-\\lambda N(t)\n\\end{align}\n\nA nuclide will decay by the $i^{th}$ mode with probability $f_i$.\n\n\\begin{align}\nf_i &= \\frac{\\mbox{decay rate by ith mode}}{\\mbox{decay rate by all modes}}\\\\\n &=\\frac{\\lambda_i}{\\lambda}\n\\end{align}\n\n## Decay with Production\n\nIn reactors, isotopes decay into one another and still others are born from fission. Thus, if there is production, we can rewrite the standard decay differential equation as:\n\n\n\\begin{align}\n\\frac{dN(t)}{dt} &= -\\mbox{rate of decay} + \\mbox{rate of production}\\\\\n\\implies N(t) &= N_0 e^{-\\lambda t} + \\int_0^t dt'Q(t')e^{-\\lambda (t-t')}\\\\\n\\end{align}\n\nIf the production rate is constant, this simplifies:\n\n\n\\begin{align}\nN(t) &= N_0 e^{-\\lambda t} + \\frac{Q_0}{\\lambda}\\left[1-e^{-\\lambda t}\\right]\\\\\n\\end{align}\n\n### Fuel Depletion\n\nDecays, fissions, and absorptions compete throughout the life of the reactor.\n\n\n\n#### Aside: Reaction Rates\n\nIn a reactor, this Q can be characterized via reaction rates.\n\n- The microscopic cross section $\\sigma_{i,j}$ is just the likelihood of the event per unit area.\n- The macroscopic cross section $\\Sigma_{i,j}$is just the likelihood of the event per unit area of a certain density of target isotopes.\n- The reaction rate is the macroscopic cross section times the flux of incident neutrons.\n\n\\begin{align}\nR_{i,j}(\\vec{r}) &= N_j(\\vec{r})\\int dE \\phi(\\vec{r},E)\\sigma_{i,j}(E)\\\\\nR_{i,j}(\\vec{r}) &= \\mbox{reactions of type i involving isotope j } [reactions/cm^2s]\\\\\nN_j(\\vec{r}) &= \\mbox{number of nuclei participating in the reactions }\\\\\nE &= \\mbox{energy}\\\\\n\\phi(\\vec{r},E)&= \\mbox{flux of neutrons with energy E at position i}\\\\\n\\sigma_{i,j}(E)&= \\mbox{cross section}\\\\\n\\end{align}\n\n\nWe said this can be written more simply as $R_x = \\sigma_x I N$, where I is intensity of the neutron flux. In the notation of the above equation, we can describe the production of an isotope by neutron absorption by another isotope as :\n\n\\begin{align}\n\\mbox{isotope i production via neutron absorption in m} = f_{im}\\sigma_{am}N_m \\phi\n\\end{align}\n\n\n### Total composition evolution\n\n\\begin{align}\n\\frac{dN_i}{dt} &= \\sum_{m=1}^{M}l_{im}\\lambda_mN_m + \\phi\\sum_{m=1}^{M}f_{im}\\sigma_mN_m - (\\lambda_i + \\phi\\sigma_i + r_i - c_i)N_i + F_i\\Big|_{i\\in [1,M]}\\\\\n\\end{align}\n\\begin{align}\nN_i &= \\mbox{atom density of nuclide i}\\\\\nM &= \\mbox{number of nuclides}\\\\\nl_{im} &= \\mbox{fraction of decays of nuclide m that result in formation of nuclide i}\\\\\n\\lambda_i &= \\mbox{radioactive decay constant of nuclide i}\\\\\n\\phi &= \\mbox{neutron flux, averaged over position and energy}\\\\\nf_{im} &= \\mbox{fraction of neutron absorption by nuclide m leading to the formation of nuclide i}\\\\\n\\sigma_m &= \\mbox{average neutron absorption cross section of nuclide m}\\\\\nr_i &= \\mbox{continuous removal rate of nuclide i from the system}\\\\\nc_i &= \\mbox{continuous feed rate of nuclide i}\\\\\nF_i &= \\mbox{production rate of nuclide i directly from fission}\\\\\n\\end{align}\n\n\n\n\n\n\n\n### Example: $^{135}Xe$\n\n**Discussion: What is interesting about Xenon?**\n \n \n$^{135}Xe$ is produced directly by fission and from the decay of iodine.\n\n\\begin{align}\n\\frac{dN_{xe}}{dt} &= \\sum_{m=1}^{M}l_{Xem}\\lambda_mN_m + \\phi\\sum_{m=1}^{M}f_{Xem}\\sigma_mN_m - (\\lambda_{Xe} + \\phi\\sigma_{Xe} + r_{Xe} - c_{Xe})N_{Xe} + F_{Xe}\\\\\n &= -\\lambda_{Xe}N_{Xe} - \\sigma_{aXe}\\phi N_{Xe} + \\lambda_IN_I + F_{Xe}\\\\\n &= -\\lambda_{Xe}N_{Xe} - \\sigma_{aXe}\\phi N_{Xe} + \\lambda_IN_I + \\gamma_{Xe}\\Sigma_f\\phi\\\\\n \\gamma_{Xe} &= 0.003\\\\\n \\gamma_{I} &= 0.061\\\\\n\\end{align}\n\n### Example: $^{239}Pu$ \n\n\n\\begin{align}\n\\frac{dN_{Pu}}{dt} &= \\sum_{m=1}^{M}l_{Pum}\\lambda_mN_m + \\phi\\sum_{m=1}^{M}f_{Pum}\\sigma_mN_m - (\\lambda_{Pu} + \\phi\\sigma_{Pu} + r_{Pu} - c_{Pu})N_{Pu} + F_{Pu}\\\\\n\\end{align}\n\n\nLet's formulate this equation together.\n\n\n$$\\mathrm{^{238}_{\\ 92}U \\ + \\ ^{1}_{0}n \\ \\longrightarrow \\ ^{239}_{\\ 92}U \\ \\xrightarrow [23.5\\ min]{\\beta^-} \\ ^{239}_{\\ 93}Np \\ \\xrightarrow [2.3565\\ d]{\\beta^-} \\ ^{239}_{\\ 94}Pu}$$\n\n\n- Decay of what nuclides result in the formation of $^{239}Pu$?\n- Does $^{239}Pu$ decay?\n- Is there a nuclide that becomes $^{239}Pu$ after it absorbs a neutron?\n- Does $^{239}Pu$ ever absorb neutrons?\n- Is $^{239}Pu$ ever produced directly from fission?\n\n\n## Burnable Poisons\n\n- Gadolinia ($Gd_2O_3$) or erbia ($Er_2O_3$) common\n- Natural Erbium consists of Er166, Er167, Er168 and Er170 primarily. Er167 has large thermal cross section.\n- Gd is an early life burnable poison, typically gone by 10‐20 GWd\n- Boron also used widely.\n- Can be mixed with the fuel or a coating on the pellet.\n\n\n\n\\begin{align}\n\\frac{dN^P(t)}{dt} &= -g(t)\\sigma_{aP}N^P(t)\\phi\\\\\ng(t) &= \\frac{\\mbox{average flux inside BP}}{\\mbox{average flux in core}}\\\\\n\\sigma_{aP} &=\\mbox{neutron absorption cross section of the BP}\\\\\nN^P(t) &= \\mbox{number of atoms of the BP at time t}\n\\end{align}\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a1192cfd3651bd2f6219cf05bec5c7b5226fc888", "size": 61027, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "radioactivity/00-radioactivity.ipynb", "max_stars_repo_name": "katyhuff/npr247", "max_stars_repo_head_hexsha": "0bc7abf483247ba1a705516393f49703d8263458", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-12-17T06:07:21.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-21T17:14:51.000Z", "max_issues_repo_path": "radioactivity/00-radioactivity.ipynb", "max_issues_repo_name": "katyhuff/npr247", "max_issues_repo_head_hexsha": "0bc7abf483247ba1a705516393f49703d8263458", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2018-08-29T17:27:24.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-29T17:46:50.000Z", "max_forks_repo_path": "radioactivity/00-radioactivity.ipynb", "max_forks_repo_name": "katyhuff/npr247", "max_forks_repo_head_hexsha": "0bc7abf483247ba1a705516393f49703d8263458", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2018-08-25T20:00:51.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-14T03:05:26.000Z", "avg_line_length": 67.0626373626, "max_line_length": 4389, "alphanum_fraction": 0.572123814, "converted": true, "num_tokens": 5926, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2598256379609837, "lm_q2_score": 0.45326184801538616, "lm_q1q2_score": 0.11776904882397213}}
{"text": "```\n# This mounts your Google Drive to the Colab VM.\nfrom google.colab import drive\ndrive.mount('/content/drive')\n\n# TODO: Enter the foldername in your Drive where you have saved the unzipped\n# assignment folder, e.g. 'cs231n/assignments/assignment1/'\nFOLDERNAME = None\nassert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n\n# Now that we've mounted your Drive, this ensures that\n# the Python interpreter of the Colab VM can load\n# python files from within it.\nimport sys\nsys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n\n# This downloads the CIFAR-10 dataset to your Drive\n# if it doesn't already exist.\n%cd /content/drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n!bash get_datasets.sh\n%cd /content/drive/My\\ Drive/$FOLDERNAME\n```\n\n# Batch Normalization\nOne way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. One idea along these lines is batch normalization, proposed by [1] in 2015.\n\nTo understand the goal of batch normalization, it is important to first recognize that machine learning methods tend to perform better with input data consisting of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features. This will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance, since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n\nThe authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, they propose to insert into the network layers that normalize batches. At training time, such a layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n\nIt is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n\n[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\nInternal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)\n\n\n```\n# Setup cell.\nimport time\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom cs231n.classifiers.fc_net import *\nfrom cs231n.data_utils import get_CIFAR10_data\nfrom cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\nfrom cs231n.solver import Solver\n\n%matplotlib inline\nplt.rcParams[\"figure.figsize\"] = (10.0, 8.0) # Set default size of plots.\nplt.rcParams[\"image.interpolation\"] = \"nearest\"\nplt.rcParams[\"image.cmap\"] = \"gray\"\n\n%load_ext autoreload\n%autoreload 2\n\ndef rel_error(x, y):\n \"\"\"Returns relative error.\"\"\"\n return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n\ndef print_mean_std(x,axis=0):\n print(f\" means: {x.mean(axis=axis)}\")\n print(f\" stds: {x.std(axis=axis)}\\n\")\n```\n\n\n```\n# Load the (preprocessed) CIFAR-10 data.\ndata = get_CIFAR10_data()\nfor k, v in list(data.items()):\n print(f\"{k}: {v.shape}\")\n```\n\n# Batch Normalization: Forward Pass\nIn the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n\nReferencing the paper linked to above in [1] may be helpful!\n\n\n```\n# Check the training-time forward pass by checking means and variances\n# of features both before and after batch normalization \n\n# Simulate the forward pass for a two-layer network.\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before batch normalization:')\nprint_mean_std(a,axis=0)\n\ngamma = np.ones((D3,))\nbeta = np.zeros((D3,))\n\n# Means should be close to zero and stds close to one.\nprint('After batch normalization (gamma=1, beta=0)')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n\ngamma = np.asarray([1.0, 2.0, 3.0])\nbeta = np.asarray([11.0, 12.0, 13.0])\n\n# Now means should be close to beta and stds close to gamma.\nprint('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n```\n\n\n```\n# Check the test-time forward pass by running the training-time\n# forward pass many times to warm up the running averages, and then\n# checking the means and variances of activations after a test-time\n# forward pass.\n\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\n\nbn_param = {'mode': 'train'}\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n\nfor t in range(50):\n X = np.random.randn(N, D1)\n a = np.maximum(0, X.dot(W1)).dot(W2)\n batchnorm_forward(a, gamma, beta, bn_param)\n\nbn_param['mode'] = 'test'\nX = np.random.randn(N, D1)\na = np.maximum(0, X.dot(W1)).dot(W2)\na_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n\n# Means should be close to zero and stds close to one, but will be\n# noisier than training-time forward passes.\nprint('After batch normalization (test-time):')\nprint_mean_std(a_norm,axis=0)\n```\n\n# Batch Normalization: Backward Pass\nNow implement the backward pass for batch normalization in the function `batchnorm_backward`.\n\nTo derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n\nOnce you have finished, run the following to numerically check your backward pass.\n\n\n```\n# Gradient check batchnorm backward pass.\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nfx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\nfg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\nfb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = batchnorm_forward(x, gamma, beta, bn_param)\ndx, dgamma, dbeta = batchnorm_backward(dout, cache)\n\n# You should expect to see relative errors between 1e-13 and 1e-8.\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n# Batch Normalization: Alternative Backward Pass\nIn class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n\nSurprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too! \n\nIn the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n\nwe first calculate the mean $\\mu$ and variance $v$.\nWith $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$ and normalized data $Y$.\nThe equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n\n\\begin{align}\n& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k & v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n& \\sigma=\\sqrt{v+\\epsilon} & y_i=\\frac{x_i-\\mu}{\\sigma}\n\\end{align}\n\n\n\nThe meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n\nThe unknown/hard part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n$\\frac{\\partial \\sigma}{\\partial v}$, \n$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\nand then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n\nIf it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n\nYou should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n\nAfter doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster.\n\n\n```\nnp.random.seed(231)\nN, D = 100, 500\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nout, cache = batchnorm_forward(x, gamma, beta, bn_param)\n\nt1 = time.time()\ndx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\nt2 = time.time()\ndx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\nt3 = time.time()\n\nprint('dx difference: ', rel_error(dx1, dx2))\nprint('dgamma difference: ', rel_error(dgamma1, dgamma2))\nprint('dbeta difference: ', rel_error(dbeta1, dbeta2))\nprint('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))\n```\n\n# Fully Connected Networks with Batch Normalization\nNow that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n\nConcretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n\n**Hint:** You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`.\n\n\n```\nnp.random.seed(231)\nN, D, H1, H2, C = 2, 15, 20, 30, 10\nX = np.random.randn(N, D)\ny = np.random.randint(C, size=(N,))\n\n# You should expect losses between 1e-4~1e-10 for W, \n# losses between 1e-08~1e-10 for b,\n# and losses between 1e-08~1e-09 for beta and gammas.\nfor reg in [0, 3.14]:\n print('Running check with reg = ', reg)\n model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n reg=reg, weight_scale=5e-2, dtype=np.float64,\n normalization='batchnorm')\n\n loss, grads = model.loss(X, y)\n print('Initial loss: ', loss)\n\n for name in sorted(grads):\n f = lambda _: model.loss(X, y)[0]\n grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n if reg == 0: print()\n```\n\n# Batch Normalization for Deep Networks\nRun the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization.\n\n\n```\nnp.random.seed(231)\n\n# Try training a very deep net with batchnorm.\nhidden_dims = [100, 100, 100, 100, 100]\n\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nweight_scale = 2e-2\nbn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\nmodel = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\nprint('Solver with batch norm:')\nbn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True,print_every=20)\nbn_solver.train()\n\nprint('\\nSolver without batch norm:')\nsolver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True, print_every=20)\nsolver.train()\n```\n\nRun the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster.\n\n\n```\ndef plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n \"\"\"utility function for plotting training history\"\"\"\n plt.title(title)\n plt.xlabel(label)\n bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n bl_plot = plot_fn(baseline)\n num_bn = len(bn_plots)\n for i in range(num_bn):\n label='with_norm'\n if labels is not None:\n label += str(labels[i])\n plt.plot(bn_plots[i], bn_marker, label=label)\n label='baseline'\n if labels is not None:\n label += str(labels[0])\n plt.plot(bl_plot, bl_marker, label=label)\n plt.legend(loc='lower center', ncol=num_bn+1) \n\n \nplt.subplot(3, 1, 1)\nplot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n lambda x: x.loss_history, bl_marker='o', bn_marker='o')\nplt.subplot(3, 1, 2)\nplot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\nplt.subplot(3, 1, 3)\nplot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n# Batch Normalization and Initialization\nWe will now run a small experiment to study the interaction of batch normalization and weight initialization.\n\nThe first cell will train eight-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale.\n\n\n```\nnp.random.seed(231)\n\n# Try training a very deep net with batchnorm.\nhidden_dims = [50, 50, 50, 50, 50, 50, 50]\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nbn_solvers_ws = {}\nsolvers_ws = {}\nweight_scales = np.logspace(-4, 0, num=20)\nfor i, weight_scale in enumerate(weight_scales):\n print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\n bn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n bn_solver.train()\n bn_solvers_ws[weight_scale] = bn_solver\n\n solver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n solver.train()\n solvers_ws[weight_scale] = solver\n```\n\n\n```\n# Plot results of weight scale experiment.\nbest_train_accs, bn_best_train_accs = [], []\nbest_val_accs, bn_best_val_accs = [], []\nfinal_train_loss, bn_final_train_loss = [], []\n\nfor ws in weight_scales:\n best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n \n best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n \n final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n \nplt.subplot(3, 1, 1)\nplt.title('Best val accuracy vs. weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best val accuracy')\nplt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\nplt.legend(ncol=2, loc='lower right')\n\nplt.subplot(3, 1, 2)\nplt.title('Best train accuracy vs. weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best training accuracy')\nplt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\nplt.legend()\n\nplt.subplot(3, 1, 3)\nplt.title('Final training loss vs. weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Final training loss')\nplt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\nplt.legend()\nplt.gca().set_ylim(1.0, 3.5)\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n## Inline Question 1:\nDescribe the results of this experiment. How does the weight initialization scale affect models with/without batch normalization differently, and why?\n\n## Answer:\n[FILL THIS IN]\n\n\n# Batch Normalization and Batch Size\nWe will now run a small experiment to study the interaction of batch normalization and batch size.\n\nThe first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time.\n\n\n```\ndef run_batchsize_experiments(normalization_mode):\n np.random.seed(231)\n \n # Try training a very deep net with batchnorm.\n hidden_dims = [100, 100, 100, 100, 100]\n num_train = 1000\n small_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n }\n n_epochs=10\n weight_scale = 2e-2\n batch_sizes = [5,10,50]\n lr = 10**(-3.5)\n solver_bsize = batch_sizes[0]\n\n print('No normalization: batch size = ',solver_bsize)\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n solver = Solver(model, small_data,\n num_epochs=n_epochs, batch_size=solver_bsize,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n solver.train()\n \n bn_solvers = []\n for i in range(len(batch_sizes)):\n b_size=batch_sizes[i]\n print('Normalization: batch size = ',b_size)\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n bn_solver = Solver(bn_model, small_data,\n num_epochs=n_epochs, batch_size=b_size,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n bn_solver.train()\n bn_solvers.append(bn_solver)\n \n return bn_solvers, solver, batch_sizes\n\nbatch_sizes = [5,10,50]\nbn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')\n```\n\n\n```\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 2:\nDescribe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n\n## Answer:\n[FILL THIS IN]\n\n\n# Layer Normalization\nBatch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n\nSeveral alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n\n[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)\n\n## Inline Question 3:\nWhich of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n\n1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1. \n3. Subtracting the mean image of the dataset from each image in the dataset.\n4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n\n## Answer:\n[FILL THIS IN]\n\n\n# Layer Normalization: Implementation\n\nNow you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n\nHere's what you need to do:\n\n* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`. \n\nRun the cell below to check your results.\n* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n\nRun the second cell below to check your results.\n* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n\nRun the third cell below to run the batch size experiment on layer normalization.\n\n\n```\n# Check the training-time forward pass by checking means and variances\n# of features both before and after layer normalization.\n\n# Simulate the forward pass for a two-layer network.\nnp.random.seed(231)\nN, D1, D2, D3 =4, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before layer normalization:')\nprint_mean_std(a,axis=1)\n\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n\n# Means should be close to zero and stds close to one.\nprint('After layer normalization (gamma=1, beta=0)')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n\ngamma = np.asarray([3.0,3.0,3.0])\nbeta = np.asarray([5.0,5.0,5.0])\n\n# Now means should be close to beta and stds close to gamma.\nprint('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n```\n\n\n```\n# Gradient check batchnorm backward pass.\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nln_param = {}\nfx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\nfg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\nfb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = layernorm_forward(x, gamma, beta, ln_param)\ndx, dgamma, dbeta = layernorm_backward(dout, cache)\n\n# You should expect to see relative errors between 1e-12 and 1e-8.\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n# Layer Normalization and Batch Size\n\nWe will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!\n\n\n```\nln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 4:\nWhen is layer normalization likely to not work well, and why?\n\n1. Using it in a very deep network\n2. Having a very small dimension of features\n3. Having a high regularization term\n\n\n## Answer:\n[FILL THIS IN]\n\n", "meta": {"hexsha": "14f97c27e15913e6abe2d14c5a4e64300de780f2", "size": 36231, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignment2_colab/assignment2/BatchNormalization.ipynb", "max_stars_repo_name": "Hira63S/CS231n", "max_stars_repo_head_hexsha": "f7e174272867979a8e63ba52de35fcc70d3f3449", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "assignment2_colab/assignment2/BatchNormalization.ipynb", "max_issues_repo_name": "Hira63S/CS231n", "max_issues_repo_head_hexsha": "f7e174272867979a8e63ba52de35fcc70d3f3449", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "assignment2_colab/assignment2/BatchNormalization.ipynb", "max_forks_repo_name": "Hira63S/CS231n", "max_forks_repo_head_hexsha": "f7e174272867979a8e63ba52de35fcc70d3f3449", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.0801393728, "max_line_length": 852, "alphanum_fraction": 0.6042891447, "converted": true, "num_tokens": 6866, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4378234991142019, "lm_q2_score": 0.26894142722948733, "lm_q1q2_score": 0.11774887672638164}}
{"text": "```python\n%run ../../common/import_all.py\n\nfrom common.setup_notebook import set_css_style, setup_matplotlib, config_ipython\nconfig_ipython()\nsetup_matplotlib()\nset_css_style()\n```\n\n\n\n\n\n\n\n\n\n\n# (Some of) the most famous distributions\n\nLet's go look at some of the most famous/common distributions you can see around. Not exhaustive and maybe you could even say that what's most popular is a matter of who you are.\n\nNow that we're at it, let's also calculate expected value and variance (at least) for these ones. For what those things are, have a look at the notebook about moments of a distribution in this same section!\n\n## Easy-peasy: the Uniform\n\nGiven a continuous variable $X$ taking values in interval $\\in [a,b]$, a *uniform* distribution is one where every possible value has the same probability. Its pdf is simply\n\n$$\np(x) = \\frac{1}{b-a} \\ ,\n$$\n\nbecause you have 1 case over the total possible cases, which is the width of the interval.\n\nThe expected value is \n\n$$\n\\mathbb{E}[X] = \\int_a^b \\text{d} x \\ \\frac{1}{b-a} = \\frac{b+a}{2} \\ ,\n$$\n\nwhich, as expected (!), corresponds to the middle point of the interval because given that every point is equiprobable, this is where we fall by averaging values.\n\nThe variance is \n\n$$\n\\begin{align}\nVar[X] &= \\int_a^b \\text{d} x \\ x \\Big(x - \\frac{1}{b-a}\\Big)^2 \\\\\n&= \\int_a^b \\text{d} x \\ x^3 - 2x^2\\frac{1}{b-a} + \\frac{x}{(b-a)^2} \\\\ \n&= \\frac{b^4 - a^4}{4} - \\frac{2}{3} \\frac{b^3 - a^3}{b-a} + \\frac{b^2-a^2}{2(b-a)^2} \\\\\n&= \\frac{(b^2 - a^2)(b^2 + a^2)}{4} - \\frac{2}{3} \\frac{(b-a)(b^2 + ab + a^2)}{b-a} + \\frac{b+a}{2(b-a)} \\\\\n& = \\ \\frac{(b-a)^2}{12} \\ .\n\\end{align}\n$$\n\n## Success or failure: the Bernoulli\n\nLet's consider a binary variable $X \\in \\{0,1\\}$, so that it can take the two values 1 (which we'll call the *success*) or 0 (which we'll call the *failure*). The prototype of this is the result of flipping of a coin. Let's also call $\\mu$ the probability of the success so that, by definition\n\n$$\nP(X=1) = \\mu \\ ; P(X=0) = 1 - \\mu \\ ,\n$$\n\nso that the [pmf](probfunctions-histogram.ipynb#The-PMF) (it is a discrete variable) can be expressed as\n\n$$\np(x;\\mu) = \\mu^x(1-\\mu)^{1-x}\n$$\n\nbecause when we have $x=1$ we are left with $\\mu$ and when we have $x=0$ we are left with $1-\\mu.$\n\nSuch distribution has expected value\n\n$$\n\\mathbb{E}[X] = \\sum_{x \\in \\{0,1\\}} x \\mu^x(1-\\mu)^{1-x} = 0 + 1\\mu(1-\\mu)^0 = \\mu\n$$\n\nand variance\n\n$$\nVar[X] = \\sum_{x \\in \\{0,1\\}} x^2 \\mu^x(1-\\mu)^{1-x} - \\mu^2 = \\mu - \\mu^2 = \\mu(1-\\mu)\n$$\n\nThe Bernoulli distribution is a special case of a binomial distribution for a single observation, see below!\n\n## More successes and more failures: the Binomial\n\nThe binomial distribution describes the probability of observing $k$ occurrences of $x=1$ in a set of $n$ samples from a Bernoulli distribution. $\\mu$ is the probability of observing $x=1$. The pmf will be then\n\n$$\np(x;\\mu) = {{n}\\choose{k}} \\mu^k (1-\\mu)^{n-k} \\ ,\n$$\n\nbecause we have ${{n}\\choose{k}}$ ways of creating groups of $k$ from $n$ values and because each extraction is a Bernoulli.\n\nThe expected value is\n\n$$\n\\mathbb{E}[X] = n \\mu\n$$\n\nand the variance is\n\n$$\nVar[X] = n \\mu (1- \\mu)\n$$\n\nHead to [Wikipedia](https://en.wikipedia.org/wiki/Binomial_distribution) for the proofs.\n\n## Extending all that^: the Multinomial\n\nIt is a multivariate generalisation of the binomial and gives the distribution over counts $m_k$ for a $k$-state discrete variable to be in state $k$ given a total of observations $n$.\n\nAn example is the extraction of $n$ balls of $k$ different colours from a bag, replacing the extracted ball after each draw. The pmf reads\n\n$$\np(m_1, m_2, \\ldots, m_k, \\mu_1, \\mu_2, \\ldots, \\mu_k, n) = {{n}\\choose{m_1 m_2 \\ldots m_k}} \\mu_1^{m_1} \\mu_2^{m_2} \\ldots \\mu_k^{m_k}\n$$\n\nand we have\n\n$$\n\\mathbb{E}[m_k] = n \\mu_k \\ ,\n$$\n\n$$\nVar[m_k] = n \\mu_k(1-\\mu_k)\n$$\n\n## He majesty the Gaussian\n\nThe gaussian distribution (after C F Gauss) is also called a *normal* distribution or, in some cases, bell curve (from its shape). Let $\\mu$ be the expected value and $\\sigma$ the standard deviation,\n\n$$\np(x; \\mu, \\sigma) = \\frac{1}{\\sqrt{2 \\pi \\sigma^2}} e^{-\\frac{1}{2 \\sigma^2} (x-\\mu)^2}\n$$\n\nIt is usually indicated as $\\mathcal N(\\mu, \\sigma^2)$, where the $\\mathcal N$ stands for \"normal\".\n\n## The Beta\n\nGiven a continuous variable $x \\in [0,1]$, the distribution is parametrized by $\\alpha, \\beta > 0$ which define its shape.\n\n$$\np(x; \\alpha, \\beta) = \\mathcal{N} x^{\\alpha-1}(1-x)^{\\beta-1} \\ ,\n$$\n\nwhere $\\mathcal{N}$ is the normalisation constant:\n\n$$\n\\mathcal{N} = \\frac{\\Gamma(\\alpha + \\beta)}{\\Gamma(\\alpha) \\Gamma(\\beta)} = \\frac{1}{\\int d u u^{\\alpha -1}(1-u)^{\\beta-1}} \\ ,\n$$\n\nwith $\\Gamma$ the gamma function (extension of the factorial to real and complex numbers), defined as\n\n$$\n\\Gamma(t) = \\int_0^\\infty x^{t-1} e^{-x} dx\n$$\n\nand \n\n$$\n\\frac{\\Gamma(\\alpha + \\beta)}{\\Gamma(\\alpha) \\Gamma(\\beta)} = \\frac{1}{B(\\alpha, \\beta)} \\ ,\n$$\n\n$B$ being the beta function.\n\nThe beta distribution is the conjugate prior of the Bernoulli distribution for which $\\alpha$ and $\\beta$ are the prior number of observations $x=1$ and $x=0$. When $\\alpha=\\beta=1$, it reduces to a uniform distribution.\n\n## The Student's t\n\n*Student* was the pseudonym of W Gosset, which we can all consider ourselves very grateful to, given all his work in statistics. He was working at the Guinness brewery in Dublin, produces various intellectual findings while working with beer data, but had to publish under a false name due to company's regulations, and he chose \"Student\". \n\nThis distribution arises when estimating the mean of a normally distributed population in situations where the sample size is mall and the population standard deviation is unknown. Hence, it describes a sample extracted from said population: the larger the sample, the more the distribution resembles the normal.\n\n$$\np(x; \\nu) = \\frac{\\Gamma(\\frac{\\nu+1}{2})}{\\sqrt{\\nu \\pi} \\Gamma(\\frac{\\nu}{2})} \\Big(1 + \\frac{x^2}{\\nu}\\Big)^{-\\frac{\\nu+1}{2}}\n$$\n\n$\\nu$ is the number of degrees of freedom. For $\\nu=1$, the distribution reduces to the Cauchy distribution.\n\n## The elegant Chi-squared, $\\chi^2$\n\nIt is the distribution (with $k$ degrees of freedom) of the sum of the squares of $k$ independent standardised normal variables $z_i$ (that is, normal variables standardised to have mean 0 and standard deviation 1). It is a special case of the $\\Gamma$ distribution.\n\n$$\nQ = \\sum_1^k z_i^2 \\ ,\n$$\n\nSo \n\n$$\nQ \\sim \\chi^2(k)\n$$\n\nand depends on the degrees of freedom.\n\n## The Poisson: events in time or space\n\nIt is a discrete probability distribution and describes the probability that a given number of events occurs in a fixed interval of time and/or space if they are known to occur with a certain (known) average rate and independently of the time and/or distance of the last event.\n\nAn example is the mail you receive per day. Suppose on average you receive 4 mails per day. Assuming that the events \"mail arriving\" are independent, then it is reasonable to assume that the number of mails received each day follows a Poissonian. Other examples are the number of people in a queue at a given time of the day or the number of goals scored in a world cup match, see below.\n\n$$\nP(k) = \\frac{\\lambda^k e^{-\\lambda}}{k!} \\ ,\n$$\n\nwhere $k = 0, 1, 2, \\ldots$ is the number of events in an interval and $\\lambda$ the average number of such events in the same interval.\n\nThe expected value is \n\n$$\n\\mathbb{E}[k] = \\sum_{k \\geq 0} k \\frac{\\lambda^k e^{-\\lambda}}{k!} = \\sum_{k \\geq 1} \\lambda \\frac{\\lambda^{k-1}}{(k-1)!} e^{-\\lambda} = \\lambda e^{-\\lambda} e^\\lambda = \\lambda\n$$\n\nand the variance is\n\n$$\n\\begin{align*}\nVar[k] &= \\mathbb{E}[k^2] - \\mathbb{E}^2[k] \\\\\n &= \\sum^{k \\geq 0} k^2 \\frac{\\lambda^k e^{-\\lambda}}{k!} - \\lambda^2 \\\\\n &= \\lambda e^{-\\lambda} \\sum_{k \\geq 1} k \\frac{\\lambda^{k-1}}{(k-1)!} - \\lambda^2 \\\\\n &= \\lambda e^{-\\lambda} \\Big[ \\sum_{k \\geq 1} (k-1) \\frac{\\lambda^{k-1}}{(k-1)!} + \\sum_{k \\geq 1} \\frac{\\lambda^{k-1}}{(k-1)!} - \\lambda^2 \\Big] \\\\\n &= \\lambda \\Big[ \\lambda \\sum_{k \\geq 2} \\frac{1}{(k-2)!} \\lambda^{k-2} + \\sum_{k \\geq 1} \\frac{1}{(k-1)!} \\lambda^{k-1} - \\lambda^2 \\Big] \\\\\n &= \\lambda e^{-\\lambda} \\Big[ \\lambda \\sum_{k \\geq 2} \\frac{1}{(k-2)!} \\lambda^{k-2} + \\sum_{k \\geq 1} \\frac{1}{(k-1)!} \\lambda^{k-1} - \\lambda^2\\Big] \\\\\n &= \\lambda e^{-\\lambda} \\Big[ \\lambda \\sum_{i \\geq 0} \\frac{1}{i!}\\lambda^i + \\sum_{j \\geq 0} \\frac{1}{j!} \\lambda^j \\Big] \\\\\n &= \\lambda e^{- \\lambda} [\\lambda e^\\lambda + e^\\lambda] - \\lambda^2 = \\lambda^2 + \\lambda - \\lambda^2 = \\lambda\n\\end{align*}\n$$\n\nSo expected value and variance are the same and equal to the average rate of occurrence.\n\nThe Poisson distribution is appropriate if \n\n* the events are independent, _i.e._, the occurrence of one of them does not affect the probability that a second one occurs;\n* the rate st which events occur is constant;\n* two events cannot occur at the same time;\n* the probability of an occurrence of an event in an interval is proportional to the length of the interval\n\n**Example**\n\nKnowing from historical data that the average number of goals scored in a world football match is 2.5, and because the phenomenon can be described by a Poissonian, we have\n\n$$\nP(k \\text{ goals in a match}) = \\frac{2.5^k e^{-2.5}}{k!} \\ ,\n$$\n\nand we can calculate the expected value and teh variance as above.\n\nAn example of a phenomenon which violates the Poissonian assumptions would be the number of students arriving at the student union: the rate is not constant (as it is low during class time and high between class times) and events are co-occurring (students tend to come in groups).\n\n## The Dirichlet\n\nIt is a continuous multivariate distribution and the generalisation of the beta distribution, typically denoted as $\\text{Dir}(\\alpha)$, $\\alpha$ being the parametrising vector such that $\\alpha = (\\alpha_i), \\alpha_i \\in \\mathbb{R}, \\alpha_i > 0 \\forall i$. It is usually used as a prior in bayesian statistics as it is the conjugate prior of the multinomial distribution.\n\nA Dirichlet distribution of order $k \\geq 2$ with parameters $\\alpha_i$ has the probability density function\n\n$$\nf(x_1, \\ldots, x_k; \\alpha_1, \\ldots, \\alpha_k) = \\frac{1}{B(\\alpha)} \\Pi_{i=1}^k x_i^{\\alpha_i - 1}\n$$\n\nwith $B$ being the beta function in $\\mathbb{R}^{k-1}$ and $x$ living on the open $(k-1)$-dimensional simplex $x_1, \\ldots, x_k > 0$, $x_1 + \\ldots + x_{k-1} < 1$, $x_k = 1 - x_1 - \\ldots - x_{k-1}$.\n\n## The power of the power-law\n\nThe power-law is a great one, a deserves a bit of commentary.\n\n### What's a power law, in general\n\nA power law is, in general, a mathematical function of type\n\n$$\nf(x) \\propto x^\\alpha \\ ,\n$$\n\nso that in a log-log plot it will appear as a straight line because\n\n$$\nf(x) = Ax^\\alpha \\Rightarrow \\log(f(x)) = \\log A + \\alpha \\log x \\ .\n$$\n\nLet's look at it.\n\n\n```python\n# Plotting a power function \n\nx = np.array([i for i in np.arange(0.1, 1.1, 0.01)])\ny = np.array([item**-0.3 for item in x])\n\nplt.plot(x, y, label='$y = x^{-0.3}$')\nplt.xlabel('$x$')\nplt.ylabel('$y$')\nplt.xticks([i for i in np.arange(0, 1.1, 0.1)])\nplt.title(\"A power law\")\nplt.legend()\nplt.show();\n```\n\n## Power law distributions\n\nNewman's paper in [[1]](#1) is a great source about the topic and lots of what will be presented here is re-elaborated from there. It is also a very clearly written and enjoyable paper. The Wikipedia page [[3]](#3) on the topic is also quite well written.\n\nWe talk of data distributed power law when the quantity we are measuring has a probability which is a power of the quantity itself, so that a power-law distribution has a probability density function typically written as\n\n$$\np(x) = A x^{-\\alpha} \\ ,\n$$\n\nwhere $A$ is the normalisation constant.\n\nWe put a minus sign in front of the exponent (with respect to what we wrote above for a generic power-law function) as we're thinking of a decreasing relation.\n\nThere must be a minimum value $x_{min}$, otherwise it wouldn't be normalisable (the area under the curve would diverge, see figure above).\n\nAs for the exponent, we need to have $\\alpha > 1$ for it to be a pdf, hence integrable, because by definition,\n\n$$\n\\begin{align}\n1 &= \\int_{x_{min}}^\\infty p(x) \\text{d} x \\\\\n&= A \\int_{x_{min}}^\\infty x^{-\\alpha} \\text{d} x \\\\\n&= \\frac{A}{-\\alpha + 1} \\Big[x^{-\\alpha + 1}\\Big]_{x_{min}}^\\infty \\\\\n\\end{align}\n$$\n\nwhich is only non-diverging when $\\alpha > 1$. From here, the normalisation constant is $A = (\\alpha - 1) \\ x_{min}^{\\alpha-1}$.\n\n### Where you find them\n\nMany observed phenomena in several disciplines follow power-law distributions, examples are the Zipf in _linguistics_, the Pareto in _economics_, the _Taylor_ in ecology, ... In a typical situation though, it is the tail of a distribution which is power-law. \n\nIn [[5]](#5) Mandelbrot and Taleb exquisitely talk about when using a gaussian paradigm for a power law phenomenon can lead to disaster in finance.\n\n### What makes them interesting\n\n* the absence of a typical _scale_: while other distributions (the gaussian being the king example) will have a typical value which can be used as representative of the distribution (along with an error), power laws are scale-free: values can span several orders of magnitude\n\n* _scale invariance_: if the independent variable is rescaled by a factor, the law only gets affected by proportional scaling, so a consequence, this means that all power laws with the same exponents are rescaled versions of each other: \n\n$$p(cx) = A (cx)^{-\\alpha} = A c^{-\\alpha} x^{-\\alpha} \\ ,$$\n\n* _long tail_: in a power law, the tail is fat, meaning that the frequency of the highly frequent items is higher than it would be in other distributions This is brilliantly explained in this blog post by Panos Ipeirotis [[4]](#4), where he points out that despite the fact that a power law is often described as a distribution where \"there are a lot of very unfrequent items and a few very frequent ones\", this is a distortion of reality: what is striking of a power law is that actually the very frequent items occur much more frequently than they would in other distributions.\n\n### Moments\n\nThe _mean_ of a power law is only defined when $\\alpha > 2$:\n\n$$\n\\begin{align}\n\\mathrm{E}[x] = \\bar x &= A \\int_{x_{min}}^\\infty x x^{-\\alpha} \\text{d} x \\\\\n&= A \\int_{x_{min}}^\\infty x^{-\\alpha + 1} \\text{d} x \\\\\n&= \\frac{A}{-\\alpha + 2} \\Big[x^{-\\alpha + 2}\\Big]_{x_{min}}^\\infty\n\\end{align}\n$$\n\nThe _variance_ of a power law is only defined when $\\alpha > 3$:\n\n$$\n\\begin{align}\n\\mathrm{Var}[x] &= A \\int_{x_{min}}^\\infty (x-\\bar x)^2 x^{-\\alpha} \\text{d} x \\\\\n&= A \\int_{x_{min}}^\\infty x^{-\\alpha + 2} + (\\bar x)^2 x^{-\\alpha} - 2 x^{-\\alpha-1} \\bar x \\text{d} x\n\\end{align}\n$$\n\n### Plotting it\n\nA simple plot in log-log scale of the histogram of data helps the eye spot potential power-law behaviours, but this alone is a very unreliable way of identifying the distribution. Because there is much less data in the tail than there is in the head of the distribution, the tail will appear very noisy. \n\nA better way is to plot the data histogrammed, but with logarithmic binning, and in log-log scale. This helps reduce the noisy tail problem. \n\n## References\n\nTo be honest these are all about power-laws.\n\n1. x_i}|\\hat{\\theta}-x_i| \\end{aligned}\n\nDerivando ficamos com três partes. Lembre-se que a derivada da função absoluto é apenas o sinal (acima).\n\n\\begin{aligned} {\\delta L \\over \\delta \\hat{\\theta}} = \\sum_{\\theta x_i}1\n\\end{aligned}\n\nIgualando com zero chegamos em uma expressão esquisita.\n\n$$\\sum_{\\theta x_i}1$$\n\nComo interpretar a mesma? Observe que de um lado contamos os números negativos. Do outro, os positivos. O valor ótimo tem contagens iguais dos dois lados. Que número mágico separa métade dos valores de um lado e metade dos outros? A mediana!\n\n*Ao minimizar o MAE ficamos com a mediana!*\n\n## Risco\n\n\nO risco de um estimador é o valor esperado da perda do modelo em pontos escolhidos aleatoriamente. No nosso cenário, a população consiste de uma distribuição Beta. Usamos a variável aleatória $X$ para representar uma amostra: $X \\sim Beta(3, 2)$. O risco então visa responder, qual a média do erro para tal amostra? Vamos definir o risco usando MSE.\n\nUsando nossa notação, o risco $R(\\hat{\\theta})$ do nosso estimador é:\n\n$$R(\\hat{\\theta}) = \\mathbb{E}[(X - \\hat{\\theta})^2]$$\n\nNa expressão acima, usamos a perda MSE que fornece o erro interno da expectativa. Podemos definir outros riscos, mas esse é bem caracterizado (conseguimos entender o mesmo). O risco é uma função de $\\hat{\\theta}$, pois podemos mudar $\\hat{\\theta}$ como quisermos.\n\nDiferentemente da perda, o uso do risco nos permite argumentar sobre a precisão do modelo na população em geral. Se nosso modelo atingir um risco baixo, ele fará previsões precisas sobre pontos da população a longo prazo. Por outro lado, se nosso modelo tiver um risco alto, ele geralmente terá um desempenho ruim nos dados da população.\n\nNaturalmente, gostaríamos de escolher o valor de $\\hat{\\theta}$ que torna o risco o mais baixo possível. Usamos a variável $\\theta^{*}$ para representar o valor ótimo. \n\n\nSeção sendo escrita. Leia: https://www.textbook.ds100.org/ch/12/prob_risk.html. Use o translate caso necessite!\n", "meta": {"hexsha": "5462ff386ba9f3946e2b8adc4ec1609b65007bf7", "size": 297257, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_lessons/.ipynb_checkpoints/06-risco-checkpoint.ipynb", "max_stars_repo_name": "icd-ufmg/icd-ufmg.github.io", "max_stars_repo_head_hexsha": "5bc96e818938f8dec09dc93d786e4b291d298a02", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-02-25T18:25:49.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-20T19:22:24.000Z", "max_issues_repo_path": "_lessons/.ipynb_checkpoints/06-risco-checkpoint.ipynb", "max_issues_repo_name": "thiagomrs/icd-ufmg.github.io", "max_issues_repo_head_hexsha": "f72c0eca5a0f97d83be214aff52715c986b078a7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_lessons/.ipynb_checkpoints/06-risco-checkpoint.ipynb", "max_forks_repo_name": "thiagomrs/icd-ufmg.github.io", "max_forks_repo_head_hexsha": "f72c0eca5a0f97d83be214aff52715c986b078a7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-06-05T20:49:02.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T20:21:44.000Z", "avg_line_length": 350.9527744982, "max_line_length": 48464, "alphanum_fraction": 0.9300504277, "converted": true, "num_tokens": 4623, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268347662043286, "lm_q2_score": 0.24798742068237778, "lm_q1q2_score": 0.11721955616628017}}
{"text": "```python\n# This mounts your Google Drive to the Colab VM.\nfrom google.colab import drive\ndrive.mount('/content/drive')\n\n# TODO: Enter the foldername in your Drive where you have saved the unzipped\n# assignment folder, e.g. 'cs231n/assignments/assignment1/'\nFOLDERNAME = None\nassert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n\n# Now that we've mounted your Drive, this ensures that\n# the Python interpreter of the Colab VM can load\n# python files from within it.\nimport sys\nsys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n\n# This downloads the CIFAR-10 dataset to your Drive\n# if it doesn't already exist.\n%cd /content/drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n!bash get_datasets.sh\n%cd /content/drive/My\\ Drive/$FOLDERNAME\n```\n\n# Batch Normalization\nOne way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. One idea along these lines is batch normalization, proposed by [1] in 2015.\n\nTo understand the goal of batch normalization, it is important to first recognize that machine learning methods tend to perform better with input data consisting of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features. This will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance, since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n\nThe authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, they propose to insert into the network layers that normalize batches. At training time, such a layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n\nIt is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n\n[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\nInternal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)\n\n\n```python\n# Setup cell.\nimport time\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom cs231n.classifiers.fc_net import *\nfrom cs231n.data_utils import get_CIFAR10_data\nfrom cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\nfrom cs231n.solver import Solver\n\n%matplotlib inline\nplt.rcParams[\"figure.figsize\"] = (10.0, 8.0) # Set default size of plots.\nplt.rcParams[\"image.interpolation\"] = \"nearest\"\nplt.rcParams[\"image.cmap\"] = \"gray\"\n\n%load_ext autoreload\n%autoreload 2\n\ndef rel_error(x, y):\n \"\"\"Returns relative error.\"\"\"\n return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n\ndef print_mean_std(x,axis=0):\n print(f\" means: {x.mean(axis=axis)}\")\n print(f\" stds: {x.std(axis=axis)}\\n\")\n```\n\n =========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n \tYou will need to compile a Cython extension for a portion of this assignment.\n \tThe instructions to do this will be given in a section of the notebook below.\n\n\n\n```python\n# Load the (preprocessed) CIFAR-10 data.\ndata = get_CIFAR10_data()\nfor k, v in list(data.items()):\n print(f\"{k}: {v.shape}\")\n```\n\n X_train: (49000, 3, 32, 32)\n y_train: (49000,)\n X_val: (1000, 3, 32, 32)\n y_val: (1000,)\n X_test: (1000, 3, 32, 32)\n y_test: (1000,)\n\n\n# Batch Normalization: Forward Pass\nIn the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n\nReferencing the paper linked to above in [1] may be helpful!\n\n\n```python\n# Check the training-time forward pass by checking means and variances\n# of features both before and after batch normalization \n\n# Simulate the forward pass for a two-layer network.\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before batch normalization:')\nprint_mean_std(a,axis=0)\n\ngamma = np.ones((D3,))\nbeta = np.zeros((D3,))\n\n# Means should be close to zero and stds close to one.\nprint('After batch normalization (gamma=1, beta=0)')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n\ngamma = np.asarray([1.0, 2.0, 3.0])\nbeta = np.asarray([11.0, 12.0, 13.0])\n\n# Now means should be close to beta and stds close to gamma.\nprint('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n```\n\n Before batch normalization:\n means: [ -2.3814598 -13.18038246 1.91780462]\n stds: [27.18502186 34.21455511 37.68611762]\n \n After batch normalization (gamma=1, beta=0)\n means: [5.32907052e-17 5.49560397e-17 9.71445147e-18]\n stds: [0.99999999 1. 1. ]\n \n After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n means: [11. 12. 13.]\n stds: [0.99999999 1.99999999 2.99999999]\n \n\n\n\n```python\n# Check the test-time forward pass by running the training-time\n# forward pass many times to warm up the running averages, and then\n# checking the means and variances of activations after a test-time\n# forward pass.\n\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\n\nbn_param = {'mode': 'train'}\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n\nfor t in range(50):\n X = np.random.randn(N, D1)\n a = np.maximum(0, X.dot(W1)).dot(W2)\n batchnorm_forward(a, gamma, beta, bn_param)\n\nbn_param['mode'] = 'test'\nX = np.random.randn(N, D1)\na = np.maximum(0, X.dot(W1)).dot(W2)\na_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n\n# Means should be close to zero and stds close to one, but will be\n# noisier than training-time forward passes.\nprint('After batch normalization (test-time):')\nprint_mean_std(a_norm,axis=0)\n```\n\n After batch normalization (test-time):\n means: [-0.03927354 -0.04349152 -0.10452688]\n stds: [1.01531428 1.01238373 0.97819988]\n \n\n\n# Batch Normalization: Backward Pass\nNow implement the backward pass for batch normalization in the function `batchnorm_backward`.\n\nTo derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n\nOnce you have finished, run the following to numerically check your backward pass.\n\n\n```python\n# Gradient check batchnorm backward pass.\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nfx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\nfg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\nfb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = batchnorm_forward(x, gamma, beta, bn_param)\ndx, dgamma, dbeta = batchnorm_backward(dout, cache)\n\n# You should expect to see relative errors between 1e-13 and 1e-8.\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n dx error: 1.7029261167605239e-09\n dgamma error: 7.420414216247087e-13\n dbeta error: 2.8795057655839487e-12\n\n\n# Batch Normalization: Alternative Backward Pass\nIn class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n\nSurprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too! \n\nIn the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n\nwe first calculate the mean $\\mu$ and variance $v$.\nWith $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$ and normalized data $Y$.\nThe equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n\n\\begin{align}\n& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k & v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n& \\sigma=\\sqrt{v+\\epsilon} & y_i=\\frac{x_i-\\mu}{\\sigma}\n\\end{align}\n\n\n\nThe meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n\nThe unknown/hard part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n$\\frac{\\partial \\sigma}{\\partial v}$, \n$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\nand then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n\nIf it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n\nYou should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n\nAfter doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster.\n\n\n```python\nnp.random.seed(231)\nN, D = 100, 500\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nout, cache = batchnorm_forward(x, gamma, beta, bn_param)\n\nt1 = time.time()\ndx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\nt2 = time.time()\ndx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\nt3 = time.time()\n\nprint('dx difference: ', rel_error(dx1, dx2))\nprint('dgamma difference: ', rel_error(dgamma1, dgamma2))\nprint('dbeta difference: ', rel_error(dbeta1, dbeta2))\nprint('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))\n```\n\n dx difference: 7.202578502291986e-13\n dgamma difference: 0.0\n dbeta difference: 0.0\n speedup: 2.00x\n\n\n# Fully Connected Networks with Batch Normalization\nNow that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n\nConcretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n\n**Hint:** You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`.\n\n\n```python\nnp.random.seed(231)\nN, D, H1, H2, C = 2, 15, 20, 30, 10\nX = np.random.randn(N, D)\ny = np.random.randint(C, size=(N,))\n\n# You should expect losses between 1e-4~1e-10 for W, \n# losses between 1e-08~1e-10 for b,\n# and losses between 1e-08~1e-09 for beta and gammas.\nfor reg in [0, 3.14]:\n print('Running check with reg = ', reg)\n model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n reg=reg, weight_scale=5e-2, dtype=np.float64,\n normalization='batchnorm')\n\n loss, grads = model.loss(X, y)\n print('Initial loss: ', loss)\n\n for name in sorted(grads):\n f = lambda _: model.loss(X, y)[0]\n grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n if reg == 0: print()\n```\n\n Running check with reg = 0\n Initial loss: 2.2611955101340957\n W1 relative error: 1.10e-04\n W2 relative error: 3.35e-06\n W3 relative error: 3.92e-10\n b1 relative error: 1.39e-09\n b2 relative error: 5.55e-09\n b3 relative error: 8.26e-11\n beta1 relative error: 7.85e-09\n beta2 relative error: 1.89e-09\n gamma1 relative error: 7.47e-09\n gamma2 relative error: 3.35e-09\n \n Running check with reg = 3.14\n Initial loss: 5.884829928987633\n W1 relative error: 1.98e-06\n W2 relative error: 2.29e-06\n W3 relative error: 6.29e-10\n b1 relative error: 2.78e-09\n b2 relative error: 2.22e-08\n b3 relative error: 2.10e-10\n beta1 relative error: 6.32e-09\n beta2 relative error: 3.48e-09\n gamma1 relative error: 5.94e-09\n gamma2 relative error: 4.14e-09\n\n\n# Batch Normalization for Deep Networks\nRun the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization.\n\n\n```python\nnp.random.seed(231)\n\n# Try training a very deep net with batchnorm.\nhidden_dims = [100, 100, 100, 100, 100]\n\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nweight_scale = 2e-2\nbn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\nmodel = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\nprint('Solver with batch norm:')\nbn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True,print_every=20)\nbn_solver.train()\n\nprint('\\nSolver without batch norm:')\nsolver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True, print_every=20)\nsolver.train()\n```\n\n Solver with batch norm:\n (Iteration 1 / 200) loss: 2.340974\n (Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n (Epoch 1 / 10) train acc: 0.314000; val_acc: 0.267000\n (Iteration 21 / 200) loss: 2.039365\n (Epoch 2 / 10) train acc: 0.384000; val_acc: 0.280000\n (Iteration 41 / 200) loss: 2.041103\n (Epoch 3 / 10) train acc: 0.493000; val_acc: 0.308000\n (Iteration 61 / 200) loss: 1.753903\n (Epoch 4 / 10) train acc: 0.530000; val_acc: 0.307000\n (Iteration 81 / 200) loss: 1.246584\n (Epoch 5 / 10) train acc: 0.573000; val_acc: 0.313000\n (Iteration 101 / 200) loss: 1.320590\n (Epoch 6 / 10) train acc: 0.634000; val_acc: 0.338000\n (Iteration 121 / 200) loss: 1.157329\n (Epoch 7 / 10) train acc: 0.684000; val_acc: 0.326000\n (Iteration 141 / 200) loss: 1.138006\n (Epoch 8 / 10) train acc: 0.771000; val_acc: 0.323000\n (Iteration 161 / 200) loss: 0.664357\n (Epoch 9 / 10) train acc: 0.805000; val_acc: 0.344000\n (Iteration 181 / 200) loss: 0.819612\n (Epoch 10 / 10) train acc: 0.790000; val_acc: 0.322000\n \n Solver without batch norm:\n (Iteration 1 / 200) loss: 2.302332\n (Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n (Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n (Iteration 21 / 200) loss: 2.041970\n (Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n (Iteration 41 / 200) loss: 1.900473\n (Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n (Iteration 61 / 200) loss: 1.713156\n (Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n (Iteration 81 / 200) loss: 1.662209\n (Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n (Iteration 101 / 200) loss: 1.696060\n (Epoch 6 / 10) train acc: 0.535000; val_acc: 0.345000\n (Iteration 121 / 200) loss: 1.557987\n (Epoch 7 / 10) train acc: 0.530000; val_acc: 0.304000\n (Iteration 141 / 200) loss: 1.432189\n (Epoch 8 / 10) train acc: 0.628000; val_acc: 0.340000\n (Iteration 161 / 200) loss: 1.033917\n (Epoch 9 / 10) train acc: 0.661000; val_acc: 0.342000\n (Iteration 181 / 200) loss: 0.885684\n (Epoch 10 / 10) train acc: 0.701000; val_acc: 0.331000\n\n\nRun the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster.\n\n\n```python\ndef plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n \"\"\"utility function for plotting training history\"\"\"\n plt.title(title)\n plt.xlabel(label)\n bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n bl_plot = plot_fn(baseline)\n num_bn = len(bn_plots)\n for i in range(num_bn):\n label='with_norm'\n if labels is not None:\n label += str(labels[i])\n plt.plot(bn_plots[i], bn_marker, label=label)\n label='baseline'\n if labels is not None:\n label += str(labels[0])\n plt.plot(bl_plot, bl_marker, label=label)\n plt.legend(loc='lower center', ncol=num_bn+1) \n\n \nplt.subplot(3, 1, 1)\nplot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n lambda x: x.loss_history, bl_marker='o', bn_marker='o')\nplt.subplot(3, 1, 2)\nplot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\nplt.subplot(3, 1, 3)\nplot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n# Batch Normalization and Initialization\nWe will now run a small experiment to study the interaction of batch normalization and weight initialization.\n\nThe first cell will train eight-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale.\n\n\n```python\nnp.random.seed(231)\n\n# Try training a very deep net with batchnorm.\nhidden_dims = [50, 50, 50, 50, 50, 50, 50]\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nbn_solvers_ws = {}\nsolvers_ws = {}\nweight_scales = np.logspace(-4, 0, num=20)\nfor i, weight_scale in enumerate(weight_scales):\n print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\n bn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n bn_solver.train()\n bn_solvers_ws[weight_scale] = bn_solver\n\n solver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n solver.train()\n solvers_ws[weight_scale] = solver\n```\n\n Running weight scale 1 / 20\n Running weight scale 2 / 20\n Running weight scale 3 / 20\n Running weight scale 4 / 20\n Running weight scale 5 / 20\n Running weight scale 6 / 20\n Running weight scale 7 / 20\n Running weight scale 8 / 20\n Running weight scale 9 / 20\n Running weight scale 10 / 20\n Running weight scale 11 / 20\n Running weight scale 12 / 20\n Running weight scale 13 / 20\n Running weight scale 14 / 20\n Running weight scale 15 / 20\n Running weight scale 16 / 20\n\n\n E:\\Mo\\Univercity\\internship\\cs231n\\assignments\\assignment2\\cs231n\\layers.py:156: RuntimeWarning: overflow encountered in exp\n ex = np.exp(x)\n E:\\Mo\\Univercity\\internship\\cs231n\\assignments\\assignment2\\cs231n\\layers.py:157: RuntimeWarning: invalid value encountered in true_divide\n p = (ex.T / np.sum(ex, axis=1)).T\n E:\\Mo\\Univercity\\internship\\cs231n\\assignments\\assignment2\\cs231n\\layers.py:158: RuntimeWarning: divide by zero encountered in log\n loss = -np.sum(np.log(p[np.arange(num_train), y])) / num_train\n\n\n Running weight scale 17 / 20\n Running weight scale 18 / 20\n Running weight scale 19 / 20\n Running weight scale 20 / 20\n\n\n\n```python\n# Plot results of weight scale experiment.\nbest_train_accs, bn_best_train_accs = [], []\nbest_val_accs, bn_best_val_accs = [], []\nfinal_train_loss, bn_final_train_loss = [], []\n\nfor ws in weight_scales:\n best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n \n best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n \n final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n \nplt.subplot(3, 1, 1)\nplt.title('Best val accuracy vs. weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best val accuracy')\nplt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\nplt.legend(ncol=2, loc='lower right')\n\nplt.subplot(3, 1, 2)\nplt.title('Best train accuracy vs. weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best training accuracy')\nplt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\nplt.legend()\n\nplt.subplot(3, 1, 3)\nplt.title('Final training loss vs. weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Final training loss')\nplt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\nplt.legend()\nplt.gca().set_ylim(1.0, 3.5)\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n## Inline Question 1:\nDescribe the results of this experiment. How does the weight initialization scale affect models with/without batch normalization differently, and why?\n\n## Answer:\n[FILL THIS IN]\n\n\n# Batch Normalization and Batch Size\nWe will now run a small experiment to study the interaction of batch normalization and batch size.\n\nThe first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time.\n\n\n```python\ndef run_batchsize_experiments(normalization_mode):\n np.random.seed(231)\n \n # Try training a very deep net with batchnorm.\n hidden_dims = [100, 100, 100, 100, 100]\n num_train = 1000\n small_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n }\n n_epochs=10\n weight_scale = 2e-2\n batch_sizes = [5,10,50]\n lr = 10**(-3.5)\n solver_bsize = batch_sizes[0]\n\n print('No normalization: batch size = ',solver_bsize)\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n solver = Solver(model, small_data,\n num_epochs=n_epochs, batch_size=solver_bsize,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n solver.train()\n \n bn_solvers = []\n for i in range(len(batch_sizes)):\n b_size=batch_sizes[i]\n print('Normalization: batch size = ',b_size)\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n bn_solver = Solver(bn_model, small_data,\n num_epochs=n_epochs, batch_size=b_size,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n bn_solver.train()\n bn_solvers.append(bn_solver)\n \n return bn_solvers, solver, batch_sizes\n\nbatch_sizes = [5,10,50]\nbn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')\n```\n\n No normalization: batch size = 5\n Normalization: batch size = 5\n Normalization: batch size = 10\n Normalization: batch size = 50\n\n\n\n```python\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 2:\nDescribe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n\n## Answer:\n[FILL THIS IN]\n\n\n# Layer Normalization\nBatch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n\nSeveral alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n\n[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)\n\n## Inline Question 3:\nWhich of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n\n1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1. \n3. Subtracting the mean image of the dataset from each image in the dataset.\n4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n\n## Answer:\n[FILL THIS IN]\n\n\n# Layer Normalization: Implementation\n\nNow you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n\nHere's what you need to do:\n\n* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`. \n\nRun the cell below to check your results.\n* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n\nRun the second cell below to check your results.\n* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n\nRun the third cell below to run the batch size experiment on layer normalization.\n\n\n```python\n# Check the training-time forward pass by checking means and variances\n# of features both before and after layer normalization.\n\n# Simulate the forward pass for a two-layer network.\nnp.random.seed(231)\nN, D1, D2, D3 =4, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before layer normalization:')\nprint_mean_std(a,axis=1)\n\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n\n# Means should be close to zero and stds close to one.\nprint('After layer normalization (gamma=1, beta=0)')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n\ngamma = np.asarray([3.0,3.0,3.0])\nbeta = np.asarray([5.0,5.0,5.0])\n\n# Now means should be close to beta and stds close to gamma.\nprint('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n```\n\n Before layer normalization:\n means: [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n stds: [10.07429373 28.39478981 35.28360729 4.01831507]\n \n After layer normalization (gamma=1, beta=0)\n means: [ 4.81096644e-16 -7.40148683e-17 2.22044605e-16 -5.92118946e-16]\n stds: [0.99999995 0.99999999 1. 0.99999969]\n \n After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n means: [5. 5. 5. 5.]\n stds: [2.99999985 2.99999998 2.99999999 2.99999907]\n \n\n\n\n```python\n# Gradient check batchnorm backward pass.\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nln_param = {}\nfx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\nfg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\nfb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = layernorm_forward(x, gamma, beta, ln_param)\ndx, dgamma, dbeta = layernorm_backward(dout, cache)\n\n# You should expect to see relative errors between 1e-12 and 1e-8.\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n dx error: 1.4336160411201157e-09\n dgamma error: 4.519489546032799e-12\n dbeta error: 2.276445013433725e-12\n\n\n# Layer Normalization and Batch Size\n\nWe will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!\n\n\n```python\nln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 4:\nWhen is layer normalization likely to not work well, and why?\n\n1. Using it in a very deep network\n2. Having a very small dimension of features\n3. Having a high regularization term\n\n\n## Answer:\n[FILL THIS IN]\n\n", "meta": {"hexsha": "7dfbfc7656b56f4337e8e8012e07ad4032032c92", "size": 432679, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignments/assignment2/BatchNormalization.ipynb", "max_stars_repo_name": "mirzaim/cs231n", "max_stars_repo_head_hexsha": "d982c7f023a1cedd961b4104b3e652ce3c43e738", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14, "max_stars_repo_stars_event_min_datetime": "2021-11-01T12:45:47.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T09:25:18.000Z", "max_issues_repo_path": "assignments/assignment2/BatchNormalization.ipynb", "max_issues_repo_name": "surajiitd/cs231n", "max_issues_repo_head_hexsha": "d982c7f023a1cedd961b4104b3e652ce3c43e738", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "assignments/assignment2/BatchNormalization.ipynb", "max_forks_repo_name": "surajiitd/cs231n", "max_forks_repo_head_hexsha": "d982c7f023a1cedd961b4104b3e652ce3c43e738", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8, "max_forks_repo_forks_event_min_datetime": "2021-11-08T10:59:46.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-28T18:47:17.000Z", "avg_line_length": 365.4383445946, "max_line_length": 106908, "alphanum_fraction": 0.9244890554, "converted": true, "num_tokens": 9331, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.2450850131323717, "lm_q1q2_score": 0.11680253003956215}}
{"text": "```python\nfrom IPython.display import Image \nImage('../../../python_for_probability_statistics_and_machine_learning.jpg')\n```\n\n\n\n\n \n\n \n\n\n\n[Python for Probability, Statistics, and Machine Learning](https://www.springer.com/fr/book/9783319307152)\n\n\n```python\nfrom __future__ import division\n%pylab inline\n```\n\n Populating the interactive namespace from numpy and matplotlib\n\n\n WARNING: pylab import has clobbered these variables: ['f', 'clf', 'test']\n `%matplotlib` prevents importing * from pylab and numpy\n\n\n\n```python\nfrom pprint import pprint\nimport textwrap\nimport sys, re\nold_displayhook = sys.displayhook\ndef displ(x):\n if x is None: return\n print \"\\n\".join(textwrap.wrap(repr(x).replace(' ',''),width=80))\n\nsys.displayhook=displ\n```\n\nSo far, we have considered parametric methods that reduce inference\nor prediction to parameter-fitting. However, for these to work, we had to\nassume a specific functional form for the unknown probability distribution of\nthe data. Nonparametric methods eliminate the need to assume a specific\nfunctional form by generalizing to classes of functions.\n\n## Kernel Density Estimation\n\nWe have already made heavy use of this method with the histogram, which is a\nspecial case of kernel density estimation. The histogram can be considered the\ncrudest and most useful nonparametric method, that estimates the underlying\nprobability distribution of the data.\n\nTo be formal and place the histogram on the same footing as our earlier\nestimations, suppose that $\\mathscr{X}=[0,1]^d$ is the $d$ dimensional unit\ncube and that $h$ is the *bandwidth* or size of a *bin* or sub-cube. Then,\nthere are $N\\approx(1/h)^d$ such bins, each with volume $h^d$, $\\lbrace\nB_1,B_2,\\ldots,B_N \\rbrace$. With all this in place, we can write the histogram\nhas a probability density estimator of the form,\n\n$$\n\\hat{p}_h(x) = \\sum_{k=1}^N \\frac{\\hat{\\theta}_k}{h} I(x\\in B_k)\n$$\n\n where\n\n$$\n\\hat{\\theta}_k=\\frac{1}{n} \\sum_{j=1}^n I(X_j\\in B_k)\n$$\n\n is the fraction of data points ($X_k$) in each bin, $B_k$. We want to\nbound the bias and variance of $\\hat{p}_h(x)$. Keep in mind that we are trying\nto estimate a function of $x$, but the set of all possible probability\ndistribution functions is extremely large and hard to manage. Thus, we need\nto restrict our attention to the following class of probability distribution of\nso-called Lipschitz functions,\n\n$$\n\\mathscr{P}(L) = \\lbrace p\\colon \\vert p(x)-p(y)\\vert \\le L \\Vert x-y\\Vert, \\forall \\: x,y \\rbrace\n$$\n\n Roughly speaking, these are the density\nfunctions whose slopes (i.e., growth rates) are bounded by $L$.\nIt turns out that the bias of the histogram estimator is bounded in the\nfollowing way,\n\n$$\n\\int\\vert p(x)-\\mathbb{E}(\\hat{p}_h(x))\\vert dx \\le L h\\sqrt{d}\n$$\n\n Similarly, the variance is bounded by the following,\n\n$$\n\\mathbb{V}(\\hat{p}_h(x)) \\le \\frac{C}{n h^d}\n$$\n\n for some constant $C$. Putting these two facts together means that the\nrisk is bounded by,\n\n$$\nR(p,\\hat{p}) = \\int \\mathbb{E}(p(x) -\\hat{p}_h(x))^2 dx \\le L^2 h^2 d + \\frac{C}{n h^d}\n$$\n\n This upper bound is minimized by choosing\n\n$$\nh = \\left(\\frac{C}{L^2 n d}\\right)^\\frac{1}{d+2}\n$$\n\n In particular, this means that,\n\n$$\n\\sup_{p\\in\\mathscr{P}(L)} R(p,\\hat{p}) \\le C_0 \\left(\\frac{1}{n}\\right)^{\\frac{2}{d+2}}\n$$\n\n where the constant $C_0$ is a function of $L$. There is a theorem\n[[wasserman2004all]](#wasserman2004all) that shows this bound in tight, which basically means\nthat the histogram is a really powerful probability density estimator for\nLipschitz functions with risk that goes as\n$\\left(\\frac{1}{n}\\right)^{\\frac{2}{d+2}}$. Note that this class of functions\nis not necessarily smooth because the Lipschitz condition admits step-wise and\nother non-smooth functions. While this is a reassuring result, we typically do\nnot know which function class (Lipschitz or not) a particular probability\nbelongs to ahead of time. Nonetheless, the rate at which the risk changes with\nboth dimension $d$ and $n$ samples would be hard to understand without this\nresult. [Figure](#fig:nonparametric_001) shows the probability distribution\nfunction of the $\\beta(2,2)$ distribution compared to computed histograms for\ndifferent values of $n$. The box plots on each of the points show how the\nvariation in each bin of the histogram reduces with increasing $n$. The risk\nfunction $R(p,\\hat{p})$ above is based upon integrating the squared difference\nbetween the histogram (as a piecewise function of $x$) and the probability\ndistribution function. \n\n**Programming Tip.**\n\nThe corresponding IPython notebook has the complete source code that generates\n[Figure](#fig:nonparametric_001); however, the following snippet\nis the main element of the code.\n\n\n```python\ndef generate_samples(n,ntrials=500):\n phat = np.zeros((nbins,ntrials))\n for k in range(ntrials):\n d = rv.rvs(n) \n phat[:,k],_=histogram(d,bins,density=True) \n return phat\n```\n\nThe code uses the `histogram` function from Numpy.\nTo be consistent with the risk function $R(p,\\hat{p})$, we have to make sure\nthe `bins` keyword argument is formatted correctly using a sequence of\nbin-edges instead of just a single integer. Also, the `density=True` keyword\nargument normalizes the histogram appropriately so that the comparison between\nit and the probability distribution function of the simulated beta distribution\nis correctly scaled.\n\n\n\n\n\n
\n\nThe box plots on each of the points show how the variation in each bin of the histogram reduces with increasing $n$.
\n\n\n\n\n\n## Kernel Smoothing\n\nWe can extend our methods to other function classes using kernel functions.\nA one-dimensional smoothing kernel is a smooth function $K$ with \nthe following properties,\n\n$$\n\\begin{align*}\n\\int K(x) dx &= 1 \\\\\\\n\\int x K(x) dx &= 0 \\\\\\\n0< \\int x^2 K(x) dx &< \\infty \\\\\\\n\\end{align*}\n$$\n\n For example, $K(x)=I(x)/2$ is the boxcar kernel, where $I(x)=1$\nwhen $\\vert x\\vert\\le 1$ and zero otherwise. The kernel density estimator is\nvery similar to the histogram, except now we put a kernel function on every\npoint as in the following,\n\n$$\n\\hat{p}(x)=\\frac{1}{n}\\sum_{i=1}^n \\frac{1}{h^d} K\\left(\\frac{\\Vert x-X_i\\Vert}{h}\\right)\n$$\n\n where $X\\in \\mathbb{R}^d$. [Figure](#fig:nonparametric_002) shows an\nexample of a kernel density estimate using a Gaussian kernel function,\n$K(x)=e^{-x^2/2}/\\sqrt{2\\pi}$. There are five data points shown by the\nvertical lines in the upper panel. The dotted lines show the individual $K(x)$\nfunction at each of the data points. The lower panel shows the overall kernel\ndensity estimate, which is the scaled sum of the upper panel.\n\nThere is an important technical result in [[wasserman2004all]](#wasserman2004all) that\nstates that kernel density estimators are minimax in the sense we\ndiscussed in the maximum likelihood the section ref{ch:stats:sec:mle}. In\nbroad strokes, this means that the analogous risk for the kernel\ndensity estimator is approximately bounded by the following factor,\n\n$$\nR(p,\\hat{p}) \\lesssim n^{-\\frac{2 m}{2 m+d}}\n$$\n\n for some constant $C$ where $m$ is a factor related to bounding\nthe derivatives of the probability density function. For example, if the second\nderivative of the density function is bounded, then $m=2$. This means that\nthe convergence rate for this estimator decreases with increasing dimension\n$d$.\n\n\n\n
\n\nThe upper panel shows the individual kernel functions placed at each of the data points. The lower panel shows the composite kernel density estimate which is the sum of the individual functions in the upper panel.
\n\n\n\n\n\n### Cross-Validation\n\nAs a practical matter, the tricky part of the kernel density estimator (which\nincludes the histogram as a special case) is that we need to somehow compute\nthe bandwith $h$ term using data. There are several rule-of-thumb methods that\nfor some common kernels, including Silverman's rule and Scott's rule for\nGaussian kernels. For example, Scott's factor is to simply compute $h=n^{\n-1/(d+4) }$ and Silverman's is $h=(n (d+2)/4)^{ (-1/(d+4)) }$. Rules of\nthis kind are derived by assuming the underlying probability density\nfunction is of a certain family (e.g., Gaussian), and then deriving the\nbest $h$ for a certain type of kernel density estimator, usually equipped\nwith extra functional properties (say, continuous derivatives of a\ncertain order). In practice, these rules seem to work pretty well,\nespecially for uni-modal probability density functions. Avoiding these\nkinds of assumptions means computing the bandwith from data directly and that is where\ncross validation comes in.\n\nCross-validation is a method to estimate the bandwidth from the data itself.\nThe idea is to write out the following Integrated Squared Error (ISE),\n\n$$\n\\begin{align*}\n\\texttt{ISE}(\\hat{p}_h,p)&=\\int (p(x)-\\hat{p}_h(x))^2 dx\\\\\\\n &= \\int \\hat{p}_h(x)^2 dx - 2\\int p(x) \\hat{p}_h dx + \\int p(x)^2 dx \n\\end{align*}\n$$\n\n The problem with this expression is the middle term [^last_term],\n\n[^last_term]: The last term is of no interest because we are\nonly interested in relative changes in the ISE.\n\n$$\n\\int p(x)\\hat{p}_h dx\n$$\n\n where $p(x)$ is what we are trying to estimate with $\\hat{p}_h$. The\nform of the last expression looks like an expectation of $\\hat{p}_h$ over the\ndensity of $p(x)$, $\\mathbb{E}(\\hat{p}_h)$. The approach is to\napproximate this with the mean,\n\n$$\n\\mathbb{E}(\\hat{p}_h) \\approx \\frac{1}{n}\\sum_{i=1}^n \\hat{p}_h(X_i)\n$$\n\n The problem with this approach is that $\\hat{p}_h$ is computed using\nthe same data that the approximation utilizes. The way to get around this is\nto split the data into two equally sized chunks $D_1$, $D_2$; and then compute\n$\\hat{p}_h$ for a sequence of different $h$ values over the $D_1$ set. Then,\nwhen we apply the above approximation for the data ($Z_i$) in the $D_2$ set,\n\n$$\n\\mathbb{E}(\\hat{p}_h) \\approx \\frac{1}{\\vert D_2\\vert}\\sum_{Z_i\\in D_2} \\hat{p}_h(Z_i)\n$$\n\n Plugging this approximation back into the integrated squared error\nprovides the objective function,\n\n$$\n\\texttt{ISE}\\approx \\int \\hat{p}_h(x)^2 dx-\\frac{2}{\\vert D_2\\vert}\\sum_{Z_i\\in D_2} \\hat{p}_h(Z_i)\n$$\n\n Some code will make these steps concrete. We will need some tools from\nScikit-learn.\n\n\n```python\nfrom sklearn.cross_validation import train_test_split\nfrom sklearn.neighbors.kde import KernelDensity\n```\n\n The `train_test_split` function makes it easy to split and\nkeep track of the $D_1$ and $D_2$ sets we need for cross validation. Scikit-learn\nalready has a powerful and flexible implementation of kernel density estimators.\nTo compute the objective function, we need some\nbasic numerical integration tools from Scipy. For this example, we\nwill generate samples from a $\\beta(2,2)$ distribution, which is\nimplemented in the `stats` submodule in Scipy.\n\n\n```python\nimport numpy as np\nnp.random.seed(123456)\n```\n\n\n```python\nfrom scipy.integrate import quad\nfrom scipy import stats\nrv= stats.beta(2,2)\nn=100 # number of samples to generate\nd = rv.rvs(n)[:,None] # generate samples as column-vector\n```\n\n**Programming Tip.**\n\nThe use of the `[:,None]` in the last line formats the Numpy array returned by\nthe `rvs` function into a Numpy vector with a column dimension of one. This is\nrequired by the `KernelDensity` constructor because the column dimension is\nused for different features (in general) for Scikit-learn. Thus, even though we\nonly have one feature, we still need to comply with the structured input that\nScikit-learn relies upon. There are many ways to inject the additional\ndimension other than using `None`. For example, the more cryptic, `np.c_`, or\nthe less cryptic `[:,np.newaxis]` can do the same, as can the `np.reshape`\nfunction.\n\n\n\n The next step is to split the data into two halves and loop over\neach of the $h_i$ bandwidths to create a separate kernel density estimator\nbased on the $D_1$ data,\n\n\n```python\ntrain,test,_,_=train_test_split(d,d,test_size=0.5)\nkdes=[KernelDensity(bandwidth=i).fit(train) \n for i in [.05,0.1,0.2,0.3]]\n```\n\n**Programming Tip.**\n\nNote that the single underscore symbol in Python refers to the last evaluated\nresult. the above code unpacks the tuple returned by `train_test_split` into\nfour elements. Because we are only interested in the first two, we assign the\nlast two to the underscore symbol. This is a stylistic usage to make it clear\nto the reader that the last two elements of the tuple are unused.\nAlternatively, we could assign the last two elements to a pair of dummy\nvariables that we do not use later, but then the reader skimming the code may\nthink that those dummy variables are relevant.\n\n\n\n The last step is to loop over the so-created kernel density estimators\nand compute the objective function.\n\n\n```python\nimport numpy as np\nfor i in kdes:\n f = lambda x: np.exp(i.score_samples(x))\n f2 = lambda x: f(x)**2\n print 'h=%3.2f\\t %3.4f'%(i.bandwidth,quad(f2,0,1)[0]\n -2*np.mean(f(test)))\n```\n\n h=0.05\t -1.1323\n h=0.10\t -1.1336\n h=0.20\t -1.1330\n h=0.30\t -1.0810\n\n\n**Programming Tip.**\n\nThe lambda functions defined in the last block are necessary because\nScikit-learn implements the return value of the kernel density estimator as a\nlogarithm via the `score_samples` function. The numerical quadrature function\n`quad` from Scipy computes the $\\int \\hat{p}_h(x)^2 dx$ part of the objective\nfunction.\n\n\n```python\n%matplotlib inline\n\nfrom __future__ import division\nfrom matplotlib.pylab import subplots\nfig,ax=subplots()\nxi = np.linspace(0,1,100)[:,None]\nfor i in kdes:\n f=lambda x: np.exp(i.score_samples(x))\n f2 = lambda x: f(x)**2\n _=ax.plot(xi,f(xi),label='$h$='+str(i.bandwidth))\n\n_=ax.set_xlabel('$x$',fontsize=28)\n_=ax.set_ylabel('$y$',fontsize=28)\n_=ax.plot(xi,rv.pdf(xi),'k:',lw=3,label='true')\n_=ax.legend(loc=0)\nax2 = ax.twinx()\n_=ax2.hist(d,20,alpha=.3,color='gray')\n_=ax2.axis(ymax=50)\n_=ax2.set_ylabel('count',fontsize=28)\nfig.tight_layout()\n#fig.savefig('fig-statistics/nonparametric_003.png')\n```\n\n\n\n
\n\nEach line above is a different kernel density estimator for the given bandwidth as an approximation to the true density function. A plain histogram is imprinted on the bottom for reference.
\n\n\n\n\n\nScikit-learn has many more advanced tools to automate this kind of\nhyper-parameter (i.e., kernel density bandwidth) search. To utilize these\nadvanced tools, we need to format the current problem slightly differently by\ndefining the following wrapper class.\n\n\n```python\nclass KernelDensityWrapper(KernelDensity):\n def predict(self,x):\n return np.exp(self.score_samples(x))\n def score(self,test):\n f = lambda x: self.predict(x)\n f2 = lambda x: f(x)**2\n return -(quad(f2,0,1)[0]-2*np.mean(f(test)))\n```\n\n This is tantamount to reorganizing the above previous code \ninto functions that Scikit-learn requires. Next, we create the\ndictionary of parameters we want to search over (`params`) below\nand then start the grid search with the `fit` function,\n\n\n```python\nfrom sklearn.grid_search import GridSearchCV\nparams = {'bandwidth':np.linspace(0.01,0.5,10)}\nclf = GridSearchCV(KernelDensityWrapper(), param_grid=params,cv=2)\nclf.fit(d)\nprint clf.best_params_\n```\n\n {'bandwidth': 0.17333333333333334}\n\n\n The grid search iterates over all the elements in the `params`\ndictionary and reports the best bandwidth over that list of parameter values.\nThe `cv` keyword argument above specifies that we want to split the data\ninto two equally-sized sets for training and testing. We can\nalso examine the values of the objective function for each point\non the grid as follow,\n\n\n```python\nfrom pprint import pprint\npprint(clf.grid_scores_)\n```\n\n [mean: 0.60758, std: 0.07695, params: {'bandwidth': 0.01},\n mean: 1.06325, std: 0.03866, params: {'bandwidth': 0.064444444444444443},\n mean: 1.11859, std: 0.02093, params: {'bandwidth': 0.11888888888888888},\n mean: 1.13187, std: 0.01397, params: {'bandwidth': 0.17333333333333334},\n mean: 1.12007, std: 0.01043, params: {'bandwidth': 0.22777777777777777},\n mean: 1.09186, std: 0.00794, params: {'bandwidth': 0.28222222222222221},\n mean: 1.05391, std: 0.00601, params: {'bandwidth': 0.33666666666666667},\n mean: 1.01126, std: 0.00453, params: {'bandwidth': 0.39111111111111108},\n mean: 0.96717, std: 0.00341, params: {'bandwidth': 0.44555555555555554},\n mean: 0.92355, std: 0.00257, params: {'bandwidth': 0.5}]\n\n\n**Programming Tip.**\n\nThe `pprint` function makes the standard output prettier. The only reason for\nusing it here is to get it to look good on the printed page. Otherwise, the\nIPython notebook handles the visual rendering of output embedded in the\nnotebook via its internal `display` framework.\n\n\n\n Keep in mind that the grid search examines multiple folds for cross\nvalidation to compute the above means and standard deviations. Note that there\nis also a `RandomizedSearchCV` in case you would rather specify a distribution\nof parameters instead of a list. This is particularly useful for searching very\nlarge parameter spaces where an exhaustive grid search would be too\ncomputationally expensive. Although kernel density estimators are easy to\nunderstand and have many attractive analytical properties, they become\npractically prohibitive for large, high-dimensional data sets.\n\n## Nonparametric Regression Estimators\n\nBeyond estimating the underlying probability density, we can use nonparametric\nmethods to compute estimators of the underlying function that is generating the\ndata. Nonparametric regression estimators of the following form are known as\nlinear smoothers,\n\n$$\n\\hat{y}(x) = \\sum_{i=1}^n \\ell_i(x) y_i\n$$\n\n To understand the performance of these smoothers,\nwe can define the risk as the following,\n\n$$\nR(\\hat{y},y) = \\mathbb{E}\\left( \\frac{1}{n} \\sum_{i=1}^n (\\hat{y}(x_i)-y(x_i))^2 \\right)\n$$\n\n and find the best $\\hat{y}$ that minimizes this. The problem with\nthis metric is that we do not know $y(x)$, which is why we are trying to\napproximate it with $\\hat{y}(x)$. We could construct an estimation by using the\ndata at hand as in the following,\n\n$$\n\\hat{R}(\\hat{y},y) =\\frac{1}{n} \\sum_{i=1}^n (\\hat{y}(x_i)-Y_i)^2\n$$\n\n where we have substituted the data $Y_i$ for the unknown function\nvalue, $y(x_i)$. The problem with this approach is that we are using the data\nto estimate the function and then using the same data to evaluate the risk of\ndoing so. This kind of double-dipping leads to overly optimistic estimators.\nOne way out of this conundrum is to use leave-one-out cross validation, wherein\nthe $\\hat{y}$ function is estimated using all but one of the data pairs,\n$(X_i,Y_i)$. Then, this missing data element is used to estimate the above\nrisk. Notationally, this is written as the following,\n\n$$\n\\hat{R}(\\hat{y},y) =\\frac{1}{n} \\sum_{i=1}^n (\\hat{y}_{(-i)}(x_i)-Y_i)^2\n$$\n\n where $\\hat{y}_{(-i)}$ denotes computing the estimator without using\nthe $i^{th}$ data pair. Unfortunately, for anything other than relatively small\ndata sets, it quickly becomes computationally prohibitive to use leave-one-out\ncross validation in practice. We'll get back to this issue shortly, but let's\nconsider a concrete example of such a nonparametric smoother.\n\n## Nearest Neighbors Regression\n
\n\nThe simplest possible nonparametric regression method is the $k$-nearest\nneighbors regression. This is easier to explain in words than to write out in\nmath. Given an input $x$, find the closest one of the $k$ clusters that\ncontains it and then return the mean of the data values in that cluster. As a\nunivariate example, let's consider the following *chirp* waveform,\n\n$$\ny(x)=\\cos\\left(2\\pi\\left(f_o x + \\frac{BW x^2}{2\\tau}\\right)\\right)\n$$\n\n This waveform is important in high-resolution radar applications.\nThe $f_o$ is the start frequency and $BW/\\tau$ is the frequency slope of the\nsignal. For our example, the fact that it is nonuniform over its domain is\nimportant. We can easily create some data by sampling the\nchirp as in the following,\n\n\n```python\nimport numpy as np\nfrom numpy import cos, pi\nxi = np.linspace(0,1,100)[:,None]\nxin = np.linspace(0,1,12)[:,None]\nf0 = 1 # init frequency\nBW = 5\ny = cos(2*pi*(f0*xin+(BW/2.0)*xin**2))\n```\n\n We can use this data to construct a simple nearest neighbor\nestimator using Scikit-learn,\n\n\n```python\nfrom sklearn.neighbors import KNeighborsRegressor\nknr=KNeighborsRegressor(2) \nknr.fit(xin,y)\n```\n\n\n\n\n KNeighborsRegressor(algorithm='auto', leaf_size=30, metric='minkowski',\n metric_params=None, n_jobs=1, n_neighbors=2, p=2,\n weights='uniform')\n\n\n\n**Programming Tip.**\n\nScikit-learn has a fantastically consistent interface. The `fit` function above\nfits the model parameters to the data. The corresponding `predict` function\nreturns the output of the model given an arbitrary input. We will spend a lot\nmore time on Scikit-learn in the machine learning chapter. The `[:,None]` part\nat the end is just injecting a column dimension into the array in order to\nsatisfy the dimensional requirements of Scikit-learn.\n\n\n```python\nfrom matplotlib.pylab import subplots\nfig,ax=subplots()\nyi = cos(2*pi*(f0*xi+(BW/2.0)*xi**2))\n_=ax.plot(xi,yi,'k--',lw=2,label=r'$y(x)$')\n_=ax.plot(xin,y,'ko',lw=2,ms=11,color='gray',alpha=.8,label='$y(x_i)$')\n_=ax.fill_between(xi.flat,yi.flat,knr.predict(xi).flat,color='gray',alpha=.3)\n_=ax.plot(xi,knr.predict(xi),'k-',lw=2,label='$\\hat{y}(x)$')\n_=ax.set_aspect(1/4.)\n_=ax.axis(ymax=1.05,ymin=-1.05)\n_=ax.set_xlabel(r'$x$',fontsize=24)\n_=ax.legend(loc=0)\nfig.set_tight_layout(True)\n#fig.savefig('fig-statistics/nonparametric_004.png')\n```\n\n\n\n
\n\nThe dotted line shows the chirp signal and the solid line shows the nearest neighbor estimate. The gray circles are the sample points that we used to fit the nearest neighbor estimator. The shaded area shows the gaps between the estimator and the unsampled chirp.
\n\n\n\n\n\n [Figure](#fig:nonparametric_004) shows the sampled signal (gray\ncircles) against the values generated by the nearest neighbor estimator (solid\nline). The dotted line is the full unsampled chirp signal, which increases in\nfrequency with $x$. This is important for our example because it adds a\nnon-stationary aspect to this problem in that the function gets progressively\nwigglier with increasing $x$. The area between the estimated curve and the\nsignal is shaded in gray. Because the nearest neighbor estimator uses only two\nnearest neighbors, for each new $x$, it finds the two adjacent $X_i$ that\nbracket the $x$ in the training data and then averages the corresponding $Y_i$\nvalues to compute the estimated value. That is, if you take every adjacent pair\nof sequential gray circles in the Figure, you find that the horizontal solid line \nsplits the pair on the vertical axis. We can adjust the number of\nnearest neighbors by changing the constructor,\n\n\n```python\nknr=KNeighborsRegressor(3) \nknr.fit(xin,y)\n```\n\n\n\n\n KNeighborsRegressor(algorithm='auto', leaf_size=30, metric='minkowski',\n metric_params=None, n_jobs=1, n_neighbors=3, p=2,\n weights='uniform')\n\n\n\n\n```python\nfig,ax=subplots()\n_=ax.plot(xi,yi,'k--',lw=2,label=r'$y(x)$')\n_=ax.plot(xin,y,'ko',lw=2,ms=11,color='gray',alpha=.8,label='$y(x_i)$')\n_=ax.fill_between(xi.flat,yi.flat,knr.predict(xi).flat,color='gray',alpha=.3)\n_=ax.plot(xi,knr.predict(xi),'k-',lw=2,label='$\\hat{y}(x)$')\n_=ax.set_aspect(1/4.)\n_=ax.axis(ymax=1.05,ymin=-1.05)\n_=ax.set_xlabel(r'$x$',fontsize=24)\n_=ax.legend(loc=0)\nfig.set_tight_layout(True)\n#fig.savefig('fig-statistics/nonparametric_005.png')\n```\n\n which produces the following corresponding [Figure](#fig:nonparametric_005).\n\n\n\n
\n\nThis is the same as [Figure](#fig:nonparametric_004) except that here there are three nearest neighbors used to build the estimator.
\n\n\n\n\n\nFor this example, [Figure](#fig:nonparametric_005) shows that with\nmore nearest neighbors the fit performs poorly, especially towards the end of\nthe signal, where there is increasing variation, because the chirp is not\nuniformly continuous.\n\nScikit-learn provides many tools for cross validation. The following code\nsets up the tools for leave-one-out cross validation,\n\n\n```python\nfrom sklearn.cross_validation import LeaveOneOut\nloo=LeaveOneOut(len(xin))\n```\n\n The `LeaveOneOut` object is an iterable that produces a set of\ndisjoint indices of the data --- one for fitting the model (training set)\nand one for evaluating the model (testing set), as shown\nin the next short sample,\n\n\n```python\npprint(list(LeaveOneOut(3)))\n```\n\n [(array([1, 2]), array([0])),\n (array([0, 2]), array([1])),\n (array([0, 1]), array([2]))]\n\n\n The next block loops over the disjoint sets of training and test\nindicies iterates provided by the `loo` variable to evaluate\nthe estimated risk, which is accumulated in the `out` list.\n\n\n```python\nout=[]\nfor train_index, test_index in loo:\n _=knr.fit(xin[train_index],y[train_index])\n out.append((knr.predict(xi[test_index])-y[test_index])**2)\n\nprint 'Leave-one-out Estimated Risk: ',np.mean(out),\n```\n\n Leave-one-out Estimated Risk: 1.03517136627\n\n\n The last line in the code above reports leave-one-out's estimated\nrisk. \n\nLinear smoothers of this type can be rewritten in using the following matrix,\n\n$$\n\\mathscr{S} = \\left[ \\ell_i(x_j) \\right]_{i,j}\n$$\n\n so that\n\n$$\n\\hat{\\mathbf{y}} = \\mathscr{S} \\mathbf{y}\n$$\n\n where $\\mathbf{y}=\\left[Y_1,Y_2,\\ldots,Y_n\\right]\\in \\mathbb{R}^n$\nand $\\hat{ \\mathbf{y}\n}=\\left[\\hat{y}(x_1),\\hat{y}(x_2),\\ldots,\\hat{y}(x_n)\\right]\\in \\mathbb{R}^n$.\nThis leads to a quick way to approximate leave-one-out cross validation as the\nfollowing,\n\n$$\n\\hat{R}=\\frac{1}{n}\\sum_{i=1}^n\\left(\\frac{y_i-\\hat{y}(x_i)}{1-\\mathscr{S}_{i,i}}\\right)^2\n$$\n\n However, this does not reproduce the approach in the code above\nbecause it assumes that each $\\hat{y}_{(-i)}(x_i)$ is consuming one fewer\nnearest neighbor than $\\hat{y}(x)$.\n\nWe can get this $\\mathscr{S}$ matrix from the `knr` object as in the following,\n\n\n```python\n_= knr.fit(xin,y) # fit on all data\nS=(knr.kneighbors_graph(xin)).todense()/float(knr.n_neighbors)\n```\n\n The `todense` part reformats the sparse matrix that is\nreturned into a regular Numpy `matrix`. The following shows a subsection\nof this $\\mathcal{S}$ matrix,\n\n\n```python\nprint S[:5,:5]\n```\n\n [[ 0.33333333 0.33333333 0.33333333 0. 0. ]\n [ 0.33333333 0.33333333 0.33333333 0. 0. ]\n [ 0. 0.33333333 0.33333333 0.33333333 0. ]\n [ 0. 0. 0.33333333 0.33333333 0.33333333]\n [ 0. 0. 0. 0.33333333 0.33333333]]\n\n\n The sub-blocks show the windows of the the `y` data that are being\nprocessed by the nearest neighbor estimator. For example,\n\n\n```python\nprint np.hstack([knr.predict(xin[:5]),(S*y)[:5]])#columns match\n```\n\n [[ 0.55781314 0.55781314]\n [ 0.55781314 0.55781314]\n [-0.09768138 -0.09768138]\n [-0.46686876 -0.46686876]\n [-0.10877633 -0.10877633]]\n\n\n Or, more concisely checking all entries for approximate equality,\n\n\n```python\nprint np.allclose(knr.predict(xin),S*y)\n```\n\n True\n\n\n which shows that the results from the nearest neighbor\nobject and the matrix multiply match.\n\n**Programming Tip.**\n\nNote that because we formatted the returned $\\mathscr{S}$ as a Numpy matrix, we\nautomatically get the matrix multiplication instead of default element-wise\nmultiplication in the `S*y` term.\n\n \n\n\n## Kernel Regression\n\nFor estimating the probability density, we started with the histogram and moved\nto the more general kernel density estimate. Likewise, we can also extend\nregression from nearest neighbors to kernel-based regression using the\n*Nadaraya-Watson* kernel regression estimator. Given a bandwith $h>0$, the\nkernel regression estimator is defined as the following,\n\n$$\n\\hat{y}(x)=\\frac{\\sum_{i=1}^n K\\left(\\frac{x-x_i}{h}\\right) Y_i}{\\sum_{i=1}^n K \\left( \\frac{x-x_i}{h} \\right)}\n$$\n\n Unfortunately, Scikit-learn does not implement this\nregression estimator; however, Jan Hendrik Metzen makes a compatible\nversion available on `github.com`.\n\n\n```python\nxin = np.linspace(0,1,20)[:,None]\ny = cos(2*pi*(f0*xin+(BW/2.0)*xin**2)).flatten()\n```\n\n\n```python\nfrom kernel_regression import KernelRegression\n```\n\n This code makes it possible to internally optimize over the bandwidth\nparameter using leave-one-out cross validation by specifying a grid of\npotential bandwidth values (`gamma`), as in the following,\n\n\n```python\nkr = KernelRegression(gamma=np.linspace(6e3,7e3,500))\nkr.fit(xin,y)\n```\n\n\n\n\n KernelRegression(gamma=6002.0040080160325, kernel='rbf')\n\n\n\n [Figure](#fig:nonparametric_006) shows the kernel estimator (heavy\nblack line) using the Gaussian kernel compared to the nearest neighbor\nestimator (solid light black line). As before, the data points are shown as\ncircles. [Figure](#fig:nonparametric_006) shows that the kernel estimator can\npick out the sharp peaks that are missed by the nearest neighbor estimator. \n\n\n\n
\n\nThe heavy black line is the Gaussian kernel estimator. The light black line is the nearest neighbor estimator. The data points are shown as gray circles. Note that unlike the nearest neighbor estimator, the Gaussian kernel estimator is able to pick out the sharp peaks in the training data.
\n\n\n\n\n\nThus, the difference between nearest neighbor and kernel estimation is that the\nlatter provides a smooth moving averaging of points whereas the former provides\na discontinuous averaging. Note that kernel estimates suffer near the\nboundaries where there is mismatch between the edges and the kernel\nfunction. This problem gets worse in higher dimensions because the data\nnaturally drift towards the boundaries (this is a consequence of the *curse of\ndimensionality*). Indeed, it is not possible to simultaneously maintain local\naccuracy (i.e., low bias) and a generous neighborhood (i.e., low variance). One\nway to address this problem is to create a local polynomial regression using\nthe kernel function as a window to localize a region of interest. For example,\n\n$$\n\\hat{y}(x)=\\sum_{i=1}^n K\\left(\\frac{x-x_i}{h}\\right) (Y_i-\\alpha - \\beta x_i)^2\n$$\n\n and now we have to optimize over the two linear parameters $\\alpha$\nand $\\beta$. This method is known as *local linear regression*\n[[loader2006local]](#loader2006local), [[hastie2013elements]](#hastie2013elements). Naturally, this can be\nextended to higher-order polynomials. Note that these methods are not yet\nimplemented in Scikit-learn.\n\n\n```python\nfig,ax=subplots()\n#fig.set_size_inches((12,4))\n_=ax.plot(xi,kr.predict(xi),'k-',label='kernel',lw=3)\n_=ax.plot(xin,y,'o',lw=3,color='gray',ms=12)\n_=ax.plot(xi,yi,'--',color='gray',label='chirp')\n_=ax.plot(xi,knr.predict(xi),'k-',label='nearest')\n_=ax.axis(ymax=1.1,ymin=-1.1)\n_=ax.set_aspect(1/4.)\n_=ax.axis(ymax=1.05,ymin=-1.05)\n_=ax.set_xlabel(r'$x$',fontsize=24)\n_=ax.set_ylabel(r'$y$',fontsize=24)\n_=ax.legend(loc=0)\n#fig.savefig('fig-statistics/nonparametric_006.png')\n```\n\n## Curse of Dimensionality\n\n\n```python\nsys.displayhook= old_displayhook\n```\n\n\n\n\n\n\n\nThe so-called curse of dimensionality occurs as we move into higher and higher\ndimensions. The term was coined by Bellman in 1961 while he was studying\nadaptive control processes. Nowadays, the term is vaguely refers to anything\nthat becomes more complicated as the number of dimensions increases\nsubstantially. Nevertheless, the concept is useful for recognizing\nand characterizing the practical difficulties of high-dimensional analysis and\nestimation.\n\nConsider the volume of an $n$-dimensional sphere,\n\n\n
\n\n$$\n\\begin{equation}\nV_s(n,r)= \\begin{cases}\n \\pi^{n/2} \\frac{r^n}{(n/2)!} & \\texttt{ if $n$ is even} \\\\\\\n 2^n\\pi^{(n-1)/2} \\frac{r^{ (n-1) }}{(n-1)!}((n-1)/2)! & \\texttt{ if $n$ is odd}\n\\end{cases} \n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\n Further, consider the sphere $V_s(n,1/2)$ enclosed by an $n$\ndimensional unit cube. The volume of the cube is always equal to one, but\n$\\lim_{n\\rightarrow\\infty} V_s(n,1/2) = 0$. What does this mean? It means that\nthe volume of the cube is pushed away from its center, where the embedded\nhypersphere lives. Specifically, the distance from the center of the cube to\nits vertices in $n$ dimensions is $\\sqrt{n}/2$, whereas the distance from the\ncenter of the inscribing sphere is $1/2$. This diagonal distance goes to\ninfinity as $n$ does. For a fixed $n$, the tiny spherical region at the center\nof the cube has many long spines attached to it, like a hyper-dimensional sea\nurchin or porcupine.\n\nWhat are the consequences of this? For methods that rely on nearest\nneighbors, exploiting locality to lower bias becomes intractable. For\nexample, suppose we have an $n$ dimensional space and a point near the\norigin we want to localize around. To estimate behavior around this\npoint, we need to average the unknown function about this point, but\nin a high-dimensional space, the chances of finding neighbors to\naverage are slim. Looked at from the opposing point of view, suppose\nwe have a binary variable, as in the coin-flipping problem. If we have\n1000 trials, then, based on our earlier work, we can be confident\nabout estimating the probability of heads. Now, suppose we have 10\nbinary variables. Now we have $2^{ 10 }=1024$ vertices to estimate.\nIf we had the same 1000 points, then at least 24 vertices would not\nget any data. To keep the same resolution, we would need 1000 samples\nat each vertex for a grand total of $1000\\times 1024 \\approx 10^6$\ndata points. So, for a ten fold increase in the number of variables,\nwe now have about 1000 more data points to collect to maintain the\nsame statistical resolution. This is the curse of dimensionality.\n\nPerhaps some code will clarify this. The following code generates samples in\ntwo dimensions that are plotted as points in [Figure](#fig:curse_of_dimensionality_001) with the inscribed circle in two\ndimensions. Note that for $d=2$ dimensions, most of the points are contained\nin the circle.\n\n\n```python\nimport numpy as np\nv=np.random.rand(1000,2)-1/2.\n```\n\n\n```python\nfrom matplotlib.patches import Circle\nfrom matplotlib.pylab import subplots\nfig,ax=subplots()\nfig.set_size_inches((5,5))\n_=ax.set_aspect(1)\n_=ax.scatter(v[:,0],v[:,1],color='gray',alpha=.3)\n_=ax.add_patch(Circle((0,0),0.5,alpha=.8,lw=3.,fill=False))\n#fig.savefig('fig-statistics/curse_of_dimensionality_001.pdf')\n```\n\n\n\n
\n\nTwo dimensional scatter of points randomly and independently uniformly distributed in the unit square. Note that most of the points are contained in the circle. Counter to intuition, this does not persist as the number of dimensions increases.
\n\n\n\n\n\n The next code block describes the core computation in\n[Figure](#fig:curse_of_dimensionality_002). For each of the dimensions, we\ncreate a set of uniformly distributed random variates along each dimension\nand then compute how close each $d$ dimensional vector is to the origin.\nThose that measure one half are those contained in the hypersphere. The\nhistogram of each measurment is shown in the corresponding panel in the\n[Figure](#fig:curse_of_dimensionality_002). The dark vertical line shows the threshold value. Values to the left\nof this indicate the population that are contained in the hypersphere. Thus,\n[Figure](#fig:curse_of_dimensionality_002) shows that as $d$ increases,\nfewer points are contained in the inscribed hypersphere. The following\ncode paraphrases the content of [Figure](#fig:curse_of_dimensionality_002)\n\n\n```python\nfor d in [2,3,5,10,20,50]:\n v=np.random.rand(5000,d)-1/2.\n hist([np.linalg.norm(i) for i in v])\n```\n\n\n```python\nsiz = [2,3,5,10,20,50]\nfig,axs=subplots(3,2,sharex=True)\nfig.set_size_inches((10,6))\n#fig.set_size_inches((10,8))\nfor ax,k in zip(axs.flatten(),siz):\n v=np.random.rand(5000,k)-1/2.\n _=ax.hist([np.linalg.norm(i) for i in v],color='gray',normed=True);\n _=ax.vlines(0.5,0,ax.axis()[-1]*1.1,lw=3)\n _=ax.set_title('$d=%d$'%k,fontsize=20)\n _=ax.tick_params(labelsize='small',top=False,right=False)\n _=ax.spines['top'].set_visible(False)\n _=ax.spines['right'].set_visible(False)\n _=ax.spines['left'].set_visible(False)\n _=ax.yaxis.set_visible(False)\n _=ax.axis(ymax=3.5)\n\nfig.set_tight_layout(True)\n#fig.savefig('fig-statistics/curse_of_dimensionality_002.pdf')\n```\n\n\n\n
\n\nEach panel shows the histogram of lengths of uniformly distributed $d$ dimensional random vectors. The population to the left of the dark vertical line are those that are contained in the inscribed hypersphere. This shows that fewer points are contained in the hypersphere with increasing dimension.
\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1515ebbf2813d77e86aaab515b1ea3f9ec50b480", "size": 387163, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapters/statistics/notebooks/Nonparametric.ipynb", "max_stars_repo_name": "nsydn/Python-for-Probability-Statistics-and-Machine-Learning", "max_stars_repo_head_hexsha": "d3e0f8ea475525a694a975dbfd2bf80bc2967cc6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 570, "max_stars_repo_stars_event_min_datetime": "2016-05-05T19:08:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T05:09:19.000Z", "max_issues_repo_path": "chapters/statistics/notebooks/Nonparametric.ipynb", "max_issues_repo_name": "crlsmcl/https-github.com-unpingco-Python-for-Probability-Statistics-and-Machine-Learning", "max_issues_repo_head_hexsha": "6fd69459a28c0b76b37fad79b7e8e430d09a86a5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-05-12T22:18:58.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-06T14:37:06.000Z", "max_forks_repo_path": "chapters/statistics/notebooks/Nonparametric.ipynb", "max_forks_repo_name": "crlsmcl/https-github.com-unpingco-Python-for-Probability-Statistics-and-Machine-Learning", "max_forks_repo_head_hexsha": "6fd69459a28c0b76b37fad79b7e8e430d09a86a5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 276, "max_forks_repo_forks_event_min_datetime": "2016-05-27T01:42:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T11:20:27.000Z", "avg_line_length": 207.9285714286, "max_line_length": 114721, "alphanum_fraction": 0.9002900587, "converted": true, "num_tokens": 10987, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3522017684487512, "lm_q2_score": 0.33111973962899144, "lm_q1q2_score": 0.11662095786562082}}
{"text": "```python\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nfrom auxiliary.auxiliary_figures import (get_figure1, get_figure2, get_figure3)\nfrom auxiliary.auxiliary_tables import (get_table1, get_table2, get_table3, get_table4)\nfrom auxiliary.auxiliary_data import process_data\nfrom auxiliary.auxiliary_visuals import (background_negative_green, p_value_star)\nfrom auxiliary.auxiliary_extensions import (get_flexible_table4, get_figure1_extension1, get_figure2_extension1,\n get_bias, get_figure1_extension2, get_figure2_extension2)\nimport warnings\nwarnings.filterwarnings('ignore')\nplt.rcParams['figure.figsize'] = [12, 6]\n```\n\nThe code below is needed to automatically enumerate the equations used in this notebook. \n\n\n```javascript\n%%javascript \nMathJax.Hub.Config({\n TeX: { equationNumbers: { autoNumber: \"AMS\" } }\n});\nMathJax.Hub.Queue(\n [\"resetEquationNumbers\", MathJax.InputJax.TeX],\n [\"PreProcess\", MathJax.Hub],\n [\"Reprocess\", MathJax.Hub]\n);\n```\n\n\n \n\n\n---\n# Replication of Angrist (1990)\n---\n\nThis notebook replicates the core results of the following paper: \n\n> Angrist, Joshua. (1990). [Lifetime Earnings and the Vietnam Era Draft Lottery: Evidence from Social Security Administrative Records](https://www.jstor.org/stable/2006669?seq=1#metadata_info_tab_contents). *American Economic Review*. 80. 313-36.\n\nIn the following just a few notes on how to read the remainder:\n\n- In this excerpt I replicate the Figures 1 to 3 and the Tables 1 to 4 (in some extended form) while I do not consider Table 5 to be a core result of the paper which is why it cannot be found in this notebook. \n- I follow the example of Angrist keeping his structure throughout the replication part of this notebook.\n- The naming and order of appearance of the figures does not follow the original paper but the published [correction](https://economics.mit.edu/files/7769). \n- The replication material including the partially processed data as well as some replication do-files can be found [here](https://economics.mit.edu/faculty/angrist/data1/data/angrist90).\n\n# 1. Introduction\n---\n\nFor a soft introduction to the topic, let us have a look at the goal of Angrist's article. Already in the first few lines Angrist states a clear-cut aim for his paper by making the remark that \"yet, academic research has not shown conclusively that Vietnam (or other) veterans are worse off economically than nonveterans\". He further elaborates on why research had yet been so inconclusive. He traces it back to the flaw that previous research had solely tried to estimate the effect of veteran status on subsequent earnings by comparing the latter across individuals differing in veteran status. He argues that this naive estimate might likely be biased as it is easily imaginable that specific types of men choose to enlist in the army whose unobserved characteristics imply low civilian earnings (self-selcetion on unobservables).\n\nAngrist avoids this pitfall by employing an instrumental variable strategy to obtain unbiased estimates of the effect of veteran status on earnings. For that he exploits the random nature of the Vietnam draft lottery. This lottery randomly groups people into those that are eligible to be forced to join the army and those that are not. The idea is that this randomly affects the veteran status without being linked to any unobserved characteristics that cause earnings. This allows Angrist to obtain an estimate of the treatment effect that does not suffer from the same shortcomings as the ones of previous studies. \n\nHe finds that Vietnam era veterans are worse off when it comes to long term annual real earnings as opposed to those that have not served in the army. In a secondary point he traces this back to the loss of working experience for veterans due to their service by estimating a simple structural model. \n\nIn the following sections I first walk you through the identification idea and empirical strategy. Secondly, I replicate and explain the core findings of the paper with a rather extensive elaboration on the different data sources used and some additional visualizations. Thirdly, I critically assess the paper followed by my own two extensions concluding with some overall remarks right after. \n\n# 2. Identification and Empirical Approach\n---\n\nAs already mentioned above the main goal of Angrist's paper is to determine the causal effect of veteran status on subsequent earnings. He believes for several reasons that conventional estimates that only compare earnings by veteran status are biased due to unobservables that affect both the probability of serving in the military as well as earnings over lifetime. This is conveniently shown in the causal graph below. Angrist names two potential reasons why this might be likely. First of all, he makes the point that probably people with few civilian opportunities (lower expected earnings) are more likely to register for the army. Without a measure for civilian opportunities at hand a naive estimate of the effect of military service on earnings would not be capable of capturing the causal effect. Hence, he believes that there is probably some self-selection into treatment on unobservables by individuals. In a second point, Angrist states that the selection criteria of the army might be correlated with unobserved characteristics of individuals that makes them more prone to receiving future earnings pointing into a certain direction. \n\nEconometrically spoken, Angrist argues with the following linear regression equation representing a version of the right triangle in the causal graph:\n\n\\begin{align}\n y_{cti} = \\beta_c + \\delta_t + s_i \\alpha + u_{it}.\n\\end{align}\n\nHe argues that estimating the above model with the real earnings $y_{cti}$ for an individual $i$ in cohort $c$ at time $t$ being determined by cohort and time fixed effects ($\\beta_c$ and $\\delta_t$) as well an individual effect for veteran status is biased. This is for the above given reasons that the indicator for veteran status $s_i$ is likely to be correlated with the error term $u_{it}$. \n\nAngrist's approach to avoid bias is now to employ an instrumental variable approach which is based on the accuracy of the causal graph below. \n\n\n\n
\n\nThe validity of this causal graph rests on the crucial reasoning that there is no common cause of the instrument (Draft Lottery) and the unobserved variables (U). Angrist provides the main argument that the draft lottery was essentially random in nature and hence is not correlated with any personal characteristics and therefore not linked to any unobservables that might determine military service and earnings. As will be later explained in more detail, the Vietnam draft lottery determined randomly on the basis of the birth dates whether a person is eligible to be drafted by the army in the year following the lottery. The directed graph from Draft Lottery to Military Service is therefore warranted as the fact of having a lottery number rendering a person draft-eligible increases the probability of joining the military as opposed to a person that has an excluded lottery number. \n\nThis argumentation leads Angrist to use the probability of being a veteran conditional on being draft-eligible in the lottery as an instrument for the effect of veteran status on earnings. In essence this is the Wald estimate which is equal to the following formula:\n\n\\begin{align*}\n\\hat{\\alpha}_{IV, WALD} = \\frac{E[earnings \\mid eligible = 1] - E[earnings \\mid eligible = 0]}{E[veteran \\mid eligible = 1] - E[veteran \\mid eligible = 0]}\n\\end{align*}\n\nThe nominator equals to the estimated $\\alpha$ from equation (1) while the denominator can be obtained by a first stage regression which regresses veteran status on draft-eligibility. It reduces to estimating the difference in conditional probabilities of being a veteran $prob(veteran \\mid eligible = 1) - prob(veteran \\mid eligible = 0)$. Estimates for this are obtained by Angrist through weighted least squares (WLS). This is done as Angrist does not have micro data but just grouped data (for more details see the data section in the replication). In order to obtain the estimates of the underlying micro level data it is necessary to adjust OLS by the size of the respective groups as weights. The above formula is also equivalent to a Two Stage Least Squares (2SLS) procedure in which earnings are regressed on the fitted values from a first stage regression of veteran status on eligibility. \n\nIn a last step, Angrist generalizes the Wald grouping method to more than just one group as instrument. There are 365 lottery numbers that were split up into two groups (eligible and non-eligible) for the previous Wald estimate. Those lottery numbers can also be split up even further into many more subgroups than just two, resulting in many more dummy variables as instruments. Angrist splits the lottery numbers into intervals of five which determine a group $j$. By cohort $c$ he estimates for each group $j$ the conditional probability of being a veteran $p_{cj}$. This first stage is again run by WLS. The resulting estimate $\\hat p_{cj}$ is then used to conduct the second stage regression below. \n\n\\begin{align}\n\\bar y_{ctj} = \\beta_c + \\delta_t + \\hat p_{cj} \\alpha + \\bar u_{ctj}\n\\end{align}\n\nThe details and estimation technique will be further explained when presenting the results in the replication section below. \n\n# 3. Replication\n---\n\n## 3.1 Background and Data\n\n### The Vietnam Era Draft Lottery\n\nBefore discussing how the data looks like it is worthwhile to understand how the Vietnam era draft lottery was working in order to determine to which extent it might actually serve as a valid instrument. During the Vietnam war there were several draft lotteries. They were held in the years from 1970 to 1975. The first one took place at the end of 1969 determining which men might be drafted in the following year. This procedure of determining the lottery numbers for the following year continued until 1975. The table below shows for which years there were lotteries drawn and which birth years were affected by them in the respective year. For more details have a look [here](https://www.sss.gov/history-and-records/vietnam-lotteries/). \n\n| **Year** | **Cohorts** | **Draft-Eligibility Ceiling**|\n|--------------|---------------|------------------------------|\n| 1970 | 1944-50 | 195 |\n| 1971 | 1951 | 125 |\n| 1972 | 1952 | 95 |\n| 1973 | 1953 | 95 |\n| 1974 | 1954 | 95 |\n| 1975 | 1955 | 95 |\n| 1976 | 1956 | 95 |\n\nThe authority of drafting men for the army through the lottery expired on June 30, 1973 and already before no one was drafted anymore. The last draft call took place on December 7, 1972. \n\nThe general functioning of those seven lotteries was that every possible birthday (365 days) was randomly assigned a number between 1 and 365 without replacement. Taking the 1969 lottery this meant that the birthdate that had the number 1 assigned to, it caused every man born on that day in the years 1944 to 1950 to be drafted first if it came to a draft call in the year 1970. In practice, later in the same year of the draft lottery, the army announced draft-eligibility ceilings determining up to which draft lottery number was called in the following year. In 1970, this means that every man having a lottery number of below 195 was called to join the army. As from 1973 on nobody was called anymore, the numbers for the ceiling are imputed from the last observed one which was 95 in the year 1972. Men with lottery numbers below the ceiling for their respective year are from here on called \"draft-eligible\". \n\nBeing drafted did not mean that one actually had to serve in the army, though. Those drafted had to pass mental and physical tests which in the end decided who had to join. Further it should be mentioned that Angrist decides to only use data on those that turned 19 when being at risk of induction which includes men born between 1950 and 1953.\n\n### The Data\n\n#### Continuous Work History Sample (CWHS)\n\nThis administrative data set constitutes a random one percent sample draw of all possible social security numbers in the US. For the years from 1964 until 1984 it includes the **FICA** (social security) earnings history censored to the Social Security maximum taxable amount. It further includes FICA taxable earnings from self-employment. For the years from 1978 on it also has a series on total earnings (**Total W-2**) including for instance cash payments but excluding earnings from self-employment. This data set has some confidentiality restrictions which means that only group averages and variances were available. This means that Angrist cannot rely on micro data but has to work with sample moment which is a crucial factor for the exact implementation of the IV method. A group is made of by year of earnings, year of birth, ethnicity and five consecutive lottery numbers. The statistics collected for those also include the number of people in the group, the fraction of them having taxable earnings equal and above the taxable maximum and the fraction having zero earnings. \n\nRegarding the actual data sets available for replication we have the data set `cwhsa` which consists of the above data for the years from 1964 to 1977 and then `cwhsb` which consists of the CWHS for the years after.\n\nAbove that Angrist provides the data set `cwhsc_new` which includes the **adjusted FICA** earnings. For those Angrist employed a strategy to approximate the underlying uncensored FICA earnings from the reported censored ones. All of those three different earnings variables are used repeatedly throughout the replication. \n\n\n```python\nprocess_data(\"cwhsa\")\n```\n\n\n\n\n\n\n
\n \n \n earnings \n earnings variance \n sample size \n fraction zero earnings \n \n \n ethnicity \n birth year \n year \n lottery interval \n \n \n \n \n 1 \n 44 \n 64 \n 1 \n 1691.030029 \n 1480.599976 \n 182.0 \n 0.170 \n \n \n 2 \n 1535.430054 \n 1359.020020 \n 187.0 \n 0.187 \n \n \n 3 \n 1818.010010 \n 1604.420044 \n 210.0 \n 0.171 \n \n \n 4 \n 1636.380005 \n 1626.270020 \n 208.0 \n 0.231 \n \n \n 5 \n 1889.800049 \n 1639.609985 \n 207.0 \n 0.184 \n \n \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n \n \n 2 \n 53 \n 77 \n 69 \n 3643.739990 \n 4273.600098 \n 53.0 \n 0.415 \n \n \n 70 \n 4127.490234 \n 5623.089844 \n 55.0 \n 0.473 \n \n \n 71 \n 4712.459961 \n 4588.279785 \n 76.0 \n 0.316 \n \n \n 72 \n 4676.939941 \n 5321.140137 \n 85.0 \n 0.353 \n \n \n 73 \n 4651.870117 \n 4989.020020 \n 83.0 \n 0.241 \n \n \n
\n
20440 rows × 4 columns
\n
\n\n
\n \n \n earnings \n earnings variance \n sample size \n fraction zero earnings \n \n \n data source \n ethnicity \n birth year \n year \n lottery interval \n \n \n \n \n TAXAB \n 1 \n 44 \n 78 \n 1 \n 10625.58 \n 7052.47 \n 179 \n 0.179 \n \n \n 2 \n 11546.46 \n 8032.55 \n 182 \n 0.198 \n \n \n 3 \n 11401.16 \n 7508.27 \n 209 \n 0.196 \n \n \n 4 \n 10899.99 \n 7342.60 \n 206 \n 0.189 \n \n \n 5 \n 11667.14 \n 7507.56 \n 207 \n 0.159 \n \n \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n \n \n TOTAL \n 2 \n 53 \n 84 \n 69 \n 6846.43 \n 9117.49 \n 53 \n 0.396 \n \n \n 70 \n 11357.89 \n 14734.47 \n 55 \n 0.455 \n \n \n 71 \n 8695.86 \n 9613.24 \n 76 \n 0.368 \n \n \n 72 \n 14013.24 \n 14182.30 \n 84 \n 0.274 \n \n \n 73 \n 10742.71 \n 18095.78 \n 83 \n 0.506 \n \n \n
\n
20440 rows × 4 columns
\n
\n\n
\n \n \n earnings \n probability of serving \n \n \n data source \n ethnicity \n birth year \n year \n lottery interval \n \n \n \n \n ADJ \n 1 \n 50 \n 74 \n 1 \n 8853.940430 \n 0.352700 \n \n \n 75 \n 1 \n 9062.639648 \n 0.352700 \n \n \n 76 \n 1 \n 10096.055664 \n 0.352700 \n \n \n 77 \n 1 \n 10916.072266 \n 0.352700 \n \n \n 78 \n 1 \n 11738.444336 \n 0.352700 \n \n \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n \n \n TOTAL \n 2 \n 53 \n 84 \n 37 \n 10562.357422 \n 0.111818 \n \n \n 57 \n 8988.295898 \n 0.082410 \n \n \n 40 \n 9857.195312 \n 0.111429 \n \n \n 11 \n 8690.839844 \n 0.088025 \n \n \n 23 \n 9709.985352 \n 0.073750 \n \n \n
\n
12818 rows × 2 columns
\n
type FICA TOTAL byr 50 51 52 53 50 51 52 53 year Statistic \n \n 66 \n Average \n -21.810000 \n \n \n Standard Error \n 14.990000 \n \n \n 67 \n Average \n -8.020000 \n 13.170000 \n \n \n Standard Error \n 18.210000 \n 16.450000 \n \n \n 68 \n Average \n -14.900000 \n 12.340000 \n -8.960000 \n \n \n Standard Error \n 24.200000 \n 19.500000 \n 19.250000 \n \n \n 69 \n Average \n -2.100000 \n 18.790000 \n 11.420000 \n -4.090000 \n \n \n Standard Error \n 34.580000 \n 26.470000 \n 22.780000 \n 18.340000 \n \n \n 70 \n Average \n -233.870000 \n -44.830000 \n -5.070000 \n 32.940000 \n \n \n Standard Error \n 39.720000 \n 36.700000 \n 29.380000 \n 24.200000 \n \n \n 71 \n Average \n -325.950000 \n -298.210000 \n -29.420000 \n 27.680000 \n \n \n Standard Error \n 46.630000 \n 41.780000 \n 40.260000 \n 30.350000 \n \n \n 72 \n Average \n -203.580000 \n -197.450000 \n -261.600000 \n 2.130000 \n \n \n Standard Error \n 55.420000 \n 51.180000 \n 46.890000 \n 42.920000 \n \n \n 73 \n Average \n -226.650000 \n -228.860000 \n -357.780000 \n -56.580000 \n \n \n Standard Error \n 67.840000 \n 61.640000 \n 56.260000 \n 54.810000 \n \n \n 74 \n Average \n -243.040000 \n -155.460000 \n -402.740000 \n -15.060000 \n \n \n Standard Error \n 81.450000 \n 75.330000 \n 68.380000 \n 68.150000 \n \n \n 75 \n Average \n -295.240000 \n -99.210000 \n -304.590000 \n -28.300000 \n \n \n Standard Error \n 94.420000 \n 89.790000 \n 85.010000 \n 79.630000 \n \n \n 76 \n Average \n -314.220000 \n -86.870000 \n -370.780000 \n -145.510000 \n \n \n Standard Error \n 106.620000 \n 102.940000 \n 98.300000 \n 93.080000 \n \n \n 77 \n Average \n -262.640000 \n -274.230000 \n -396.970000 \n -85.510000 \n \n \n Standard Error \n 117.910000 \n 112.260000 \n 111.180000 \n 107.140000 \n \n \n 78 \n Average \n -205.400000 \n -203.880000 \n -467.100000 \n -65.320000 \n 1059.400000 \n 233.270000 \n 175.360000 \n -1974.550000 \n \n \n Standard Error \n 132.710000 \n 127.040000 \n 127.300000 \n 123.190000 \n 2159.340000 \n 1609.440000 \n 1567.940000 \n 912.110000 \n \n \n 79 \n Average \n -263.610000 \n -60.530000 \n -236.900000 \n 89.280000 \n -1588.720000 \n 523.690000 \n -580.860000 \n -557.940000 \n \n \n Standard Error \n 160.590000 \n 152.390000 \n 153.920000 \n 148.700000 \n 1575.610000 \n 1590.540000 \n 736.750000 \n 750.140000 \n \n \n 80 \n Average \n -339.160000 \n -267.980000 \n -312.110000 \n -93.880000 \n -1028.120000 \n 85.630000 \n -581.320000 \n -428.730000 \n \n \n Standard Error \n 183.250000 \n 175.310000 \n 178.230000 \n 170.740000 \n 756.860000 \n 599.870000 \n 309.170000 \n 341.540000 \n \n \n 81 \n Average \n -435.830000 \n -358.320000 \n -342.890000 \n 34.390000 \n -589.670000 \n -71.610000 \n -440.530000 \n -109.540000 \n \n \n Standard Error \n 210.590000 \n 203.670000 \n 206.880000 \n 199.070000 \n 299.430000 \n 423.400000 \n 265.080000 \n 245.250000 \n \n \n 82 \n Average \n -320.200000 \n -117.310000 \n -235.120000 \n 29.490000 \n -305.540000 \n -72.760000 \n -514.710000 \n 18.720000 \n \n \n Standard Error \n 235.860000 \n 229.140000 \n 232.380000 \n 222.660000 \n 345.490000 \n 372.160000 \n 296.570000 \n 281.910000 \n \n \n 83 \n Average \n -349.580000 \n -314.060000 \n -437.740000 \n -96.370000 \n -512.940000 \n -896.550000 \n -915.710000 \n 30.160000 \n \n \n Standard Error \n 261.670000 \n 253.270000 \n 257.550000 \n 248.770000 \n 441.220000 \n 426.380000 \n 395.260000 \n 318.120000 \n \n \n 84 \n Average \n -484.390000 \n -398.460000 \n -436.060000 \n -228.680000 \n -1143.320000 \n -809.200000 \n -767.240000 \n -164.210000 \n \n \n Standard Error \n 286.830000 \n 279.260000 \n 281.930000 \n 272.260000 \n 492.270000 \n 380.960000 \n 376.060000 \n 366.100000 \n \n
\n\n\n\nFor the nonwhite males there is no clear cut pattern. Only few cells show significant results which is why Angrist in the following focuses on white males when constructing IV estimates. For completeness I present Table 1 for nonwhite males below although it is somewhat less important for the remainder of the paper.\n\n\n```python\ntable1[\"nonwhite\"].style.applymap(background_negative_green)\n```\n\n\n\n\n type FICA TOTAL byr 50 51 52 53 50 51 52 53 year Statistic \n \n 66 \n Average \n -11.880000 \n \n \n Standard Error \n 27.690000 \n \n \n 67 \n Average \n 12.910000 \n -4.030000 \n \n \n Standard Error \n 34.230000 \n 30.660000 \n \n \n 68 \n Average \n -29.540000 \n -6.290000 \n -12.040000 \n \n \n Standard Error \n 44.510000 \n 37.400000 \n 35.050000 \n \n \n 69 \n Average \n -5.130000 \n 67.800000 \n 3.450000 \n -42.420000 \n \n \n Standard Error \n 66.850000 \n 53.410000 \n 43.420000 \n 36.490000 \n \n \n 70 \n Average \n -99.820000 \n 62.250000 \n 24.750000 \n -0.950000 \n \n \n Standard Error \n 78.600000 \n 75.740000 \n 62.270000 \n 45.000000 \n \n \n 71 \n Average \n -164.810000 \n -144.310000 \n -25.080000 \n 18.230000 \n \n \n Standard Error \n 92.750000 \n 86.500000 \n 85.190000 \n 60.790000 \n \n \n 72 \n Average \n -188.880000 \n -156.720000 \n -208.280000 \n 60.440000 \n \n \n Standard Error \n 113.610000 \n 105.730000 \n 104.280000 \n 92.830000 \n \n \n 73 \n Average \n -85.730000 \n -134.890000 \n -175.680000 \n 115.590000 \n \n \n Standard Error \n 137.790000 \n 127.080000 \n 129.090000 \n 119.480000 \n \n \n 74 \n Average \n -179.350000 \n -96.710000 \n -181.420000 \n 216.590000 \n \n \n Standard Error \n 165.090000 \n 160.130000 \n 155.650000 \n 145.200000 \n \n \n 75 \n Average \n -190.350000 \n -236.150000 \n -183.730000 \n 111.640000 \n \n \n Standard Error \n 189.320000 \n 186.810000 \n 185.880000 \n 166.950000 \n \n \n 76 \n Average \n -105.340000 \n -333.790000 \n -308.910000 \n -46.400000 \n \n \n Standard Error \n 214.710000 \n 215.410000 \n 216.540000 \n 199.360000 \n \n \n 77 \n Average \n 112.430000 \n -206.880000 \n -251.130000 \n 153.510000 \n \n \n Standard Error \n 238.500000 \n 240.490000 \n 248.540000 \n 233.510000 \n \n \n 78 \n Average \n 163.670000 \n -108.610000 \n -424.930000 \n 381.910000 \n -1145.070000 \n 2978.240000 \n -4676.250000 \n -482.800000 \n \n \n Standard Error \n 272.670000 \n 269.280000 \n 279.480000 \n 275.770000 \n 2395.620000 \n 2869.680000 \n 1393.130000 \n 2206.090000 \n \n \n 79 \n Average \n 187.040000 \n -210.310000 \n -391.710000 \n 312.040000 \n 4005.420000 \n 1545.070000 \n -494.790000 \n -1043.330000 \n \n \n Standard Error \n 317.210000 \n 323.080000 \n 324.830000 \n 326.330000 \n 2721.280000 \n 2191.150000 \n 2683.890000 \n 1660.240000 \n \n \n 80 \n Average \n 203.250000 \n 4.810000 \n -212.660000 \n 344.080000 \n 790.240000 \n 376.470000 \n -292.700000 \n 288.700000 \n \n \n Standard Error \n 363.100000 \n 368.410000 \n 372.530000 \n 370.320000 \n 648.170000 \n 533.690000 \n 441.000000 \n 416.500000 \n \n \n 81 \n Average \n 534.520000 \n 313.200000 \n -305.860000 \n 717.820000 \n 802.590000 \n 415.980000 \n -272.360000 \n 784.410000 \n \n \n Standard Error \n 413.580000 \n 419.190000 \n 429.110000 \n 433.730000 \n 524.630000 \n 745.170000 \n 492.870000 \n 503.150000 \n \n \n 82 \n Average \n 285.160000 \n 175.470000 \n -262.570000 \n 810.470000 \n 326.040000 \n -244.340000 \n -160.220000 \n 675.160000 \n \n \n Standard Error \n 461.290000 \n 471.650000 \n 476.750000 \n 486.300000 \n 608.970000 \n 647.840000 \n 590.010000 \n 564.100000 \n \n \n 83 \n Average \n 96.070000 \n 419.560000 \n -177.340000 \n 543.640000 \n 315.480000 \n 254.330000 \n -53.640000 \n 462.350000 \n \n \n Standard Error \n 512.620000 \n 538.170000 \n 531.510000 \n 523.260000 \n 720.000000 \n 767.600000 \n 643.490000 \n 638.970000 \n \n \n 84 \n Average \n -76.870000 \n -223.190000 \n -123.400000 \n 641.350000 \n -287.440000 \n -718.610000 \n -288.100000 \n 827.400000 \n \n \n Standard Error \n 548.220000 \n 562.880000 \n 568.600000 \n 568.200000 \n 804.100000 \n 771.590000 \n 721.010000 \n 716.810000 \n \n
\n\n\n\n## 3.3 Measuring the Effect of Military Service on Earnings\n\n### 3.3.1 Wald-estimates \n\nAs discussed in the identification section a simple OLS regression estimating the model in equation (1) might suffer from bias due to elements of $s_i$ that are correlated with the error term $u_{it}$. This problem can be to a certain extent circumvented by the grouping method proposed by Abraham Wald (1940). Grouping the data by the instrument which is draft eligibility status makes it possible to uncover the effect of veteran status on earnings. \nAn unbiased estimate of $\\alpha$ can therefore be found by adjusting the difference in mean earnings across eligibility status by the difference in probability of becoming a veteran conditional on being either draft eligible or not. This verbal explanation is translated in the following formula:\n\n\\begin{equation}\n \\hat\\alpha = \\frac{\\bar y^e - \\bar y^n}{\\hat{p}(V|e) - \\hat{p}(V|n)}\n\\end{equation}\n\nThe variable $\\bar y$ captures the mean earnings within a certain cohort and year further defined by the superscript $e$ or $n$ which indicates draft-eligibility status. The above formula poses the problem that the conditional probabilities of being a veteran cannot be obtained from the CWHS data set alone. Therefore in **Table 2** Angrist attempts to estimate them from two other sources. First from the SIPP which has the problem that it is a quite small sample. And secondly, he matches the CWHS data to the DMDC. Here it is problematic, though, that the amount of people entering the army in 1970 (which is the year when those born 1950 were drafted) is only collected for the second half of the year. This is the reason why Angrist has to go with the estimates from the SIPP for the cohort of 1950 while taking the bigger sample of the matched DMDC/CWHS for the birth years 1951 to 53. The crucial estimates needed for the denominator of equation (3) are presented in the last column of Table 2 below. It can already be seen that the differences in earnings by eligibility that we found in Table 1 will be scaled up quite a bit to obtain the estimates for $\\hat{\\alpha}$. We will come back to that in Table 3.\n\n\nNote: The cohort 1950 for the DMDC/CWHS could not be replicated as the data for cohort 1950 from the DMDC set is missing in the replication data. Above that the standard errors for the estimates coming form SIPP differ slightly from the published results but are equal to the results from the replication code.\n
\n\n\n```python\ntable2 = get_table2(data_cwhsa, data_dmdc, data_sipp)\ntable2[\"white\"]\n```\n\n\n\n\n\n\n
\n \n \n Sample \n P(Veteran) \n P(Veteran|eligible) \n P(Veteran|ineligible) \n P(V|eligible) - P(V|ineligible) \n \n \n Data Set \n Cohort \n Statistic \n \n \n \n \n SIPP (84) \n 1950 \n Value \n 351 \n 0.2673 \n 0.3527 \n 0.1934 \n 0.1594 \n \n \n Standard Error \n 0.0136 \n 0.0215 \n 0.0166 \n 0.0272 \n \n \n 1951 \n Value \n 359 \n 0.1973 \n 0.2831 \n 0.1469 \n 0.1362 \n \n \n Standard Error \n 0.0124 \n 0.0230 \n 0.0139 \n 0.0269 \n \n \n 1952 \n Value \n 336 \n 0.1554 \n 0.2310 \n 0.1257 \n 0.1053 \n \n \n Standard Error \n 0.0111 \n 0.0245 \n 0.0119 \n 0.0273 \n \n \n 1953 \n Value \n 390 \n 0.1298 \n 0.2192 \n 0.1126 \n 0.1066 \n \n \n Standard Error \n 0.0102 \n 0.0313 \n 0.0104 \n 0.0330 \n \n \n DMDC/CWHS \n 1951 \n Value \n 16768 \n 0.1176 \n 0.2071 \n 0.0708 \n 0.1362 \n \n \n Standard Error \n 0.0025 \n 0.0053 \n 0.0024 \n 0.0059 \n \n \n 1952 \n Value \n 17703 \n 0.1515 \n 0.2683 \n 0.1102 \n 0.1581 \n \n \n Standard Error \n 0.0027 \n 0.0065 \n 0.0027 \n 0.0071 \n \n \n 1953 \n Value \n 17749 \n 0.1343 \n 0.1548 \n 0.1268 \n 0.0280 \n \n \n Standard Error \n 0.0026 \n 0.0053 \n 0.0029 \n 0.0060 \n \n \n
\n
\n\n
\n \n \n Sample \n P(Veteran) \n P(Veteran|eligible) \n P(Veteran|ineligible) \n P(V|eligible) - P(V|ineligible) \n \n \n Data Set \n Cohort \n Statistic \n \n \n \n \n SIPP (84) \n 1950 \n Value \n 70 \n 0.1625 \n 0.1957 \n 0.1355 \n 0.0603 \n \n \n Standard Error \n 0.0281 \n 0.0449 \n 0.0353 \n 0.0571 \n \n \n 1951 \n Value \n 63 \n 0.1703 \n 0.2014 \n 0.1514 \n 0.0500 \n \n \n Standard Error \n 0.0283 \n 0.0497 \n 0.0340 \n 0.0603 \n \n \n 1952 \n Value \n 52 \n 0.1332 \n 0.1449 \n 0.1288 \n 0.0161 \n \n \n Standard Error \n 0.0265 \n 0.0525 \n 0.0308 \n 0.0609 \n \n \n 1953 \n Value \n 55 \n 0.1749 \n 0.2247 \n 0.1642 \n 0.0605 \n \n \n Standard Error \n 0.0297 \n 0.0762 \n 0.0321 \n 0.0827 \n \n \n DMDC/CWHS \n 1951 \n Value \n 5258 \n 0.0794 \n 0.1173 \n 0.0599 \n 0.0574 \n \n \n Standard Error \n 0.0037 \n 0.0076 \n 0.0040 \n 0.0086 \n \n \n 1952 \n Value \n 5493 \n 0.0953 \n 0.1439 \n 0.0794 \n 0.0644 \n \n \n Standard Error \n 0.0040 \n 0.0095 \n 0.0042 \n 0.0104 \n \n \n 1953 \n Value \n 5303 \n 0.0925 \n 0.0984 \n 0.0904 \n 0.0080 \n \n \n Standard Error \n 0.0040 \n 0.0079 \n 0.0046 \n 0.0092 \n \n \n
\n
\nNote: In the last column I obtain slightly different standard errors than in the paper. The same is the case, though, in the replication code my replication is building up on.\n
\n\n\n```python\ntable3 = get_table3(data_cwhsa, data_cwhsb, data_dmdc, data_sipp, data_cwhsc_new)\np_value_star(table3[\"white\"], slice(None), (\"\", \"Service Effect in 1978 $\"))\n```\n\n\n\n\n\n\n
\n \n \n First Level \n Draft Eligibility Effects in Current $ \n \n \n Second Level \n FICA Earnings \n Adjusted FICA Earnings \n Total W-2 Earnings \n P(V|eligible) - P(V|ineligible) \n Service Effect in 1978 $ \n \n \n Cohort \n Year \n Statistic \n \n \n \n \n 1950 \n 1981 \n Value \n -435.8 \n -487.8 \n -589.7 \n 0.159 \n -2195.3* \n \n \n Standard Error \n 210.6 \n 237.6 \n 299.4 \n 0.027 \n 1069.5 \n \n \n 1982 \n Value \n -320.2 \n -396.1 \n -305.5 \n -1679 \n \n \n Standard Error \n 235.9 \n 281.7 \n 345.5 \n 1194.1 \n \n \n 1983 \n Value \n -349.6 \n -450.1 \n -512.9 \n -1849.3 \n \n \n Standard Error \n 261.7 \n 302.0 \n 441.2 \n 1240.7 \n \n \n 1984 \n Value \n -484.4 \n -638.8 \n -1143.3 \n -2517.1 \n \n \n Standard Error \n 286.8 \n 336.6 \n 492.3 \n 1326.3 \n \n \n 1951 \n 1981 \n Value \n -358.3 \n -428.8 \n -71.6 \n 0.136 \n -2258.3* \n \n \n Standard Error \n 203.7 \n 216.7 \n 423.4 \n 0.027 \n 1141.2 \n \n \n 1982 \n Value \n -117.3 \n -278.6 \n -72.8 \n -1382.1 \n \n \n Standard Error \n 229.1 \n 251.5 \n 372.2 \n 1247.5 \n \n \n 1983 \n Value \n -314.1 \n -452.2 \n -896.6 \n -2174.4 \n \n \n Standard Error \n 253.3 \n 277.7 \n 426.4 \n 1335.3 \n \n \n 1984 \n Value \n -398.5 \n -573.4 \n -809.2 \n -2644.3 \n \n \n Standard Error \n 279.3 \n 308.0 \n 381.0 \n 1420.3 \n \n \n 1952 \n 1981 \n Value \n -342.9 \n -392.7 \n -440.5 \n 0.105 \n -2675.1 \n \n \n Standard Error \n 206.9 \n 220.3 \n 265.1 \n 0.027 \n 1500.6 \n \n \n 1982 \n Value \n -235.1 \n -255.3 \n -514.7 \n -1638.2 \n \n \n Standard Error \n 232.4 \n 254.0 \n 296.6 \n 1630.1 \n \n \n 1983 \n Value \n -437.7 \n -500.1 \n -915.7 \n -3110 \n \n \n Standard Error \n 257.6 \n 283.3 \n 395.3 \n 1761.9 \n \n \n 1984 \n Value \n -436.1 \n -560.1 \n -767.2 \n -3340.9 \n \n \n Standard Error \n 281.9 \n 310.8 \n 376.1 \n 1853.8 \n \n \n
\n
\n\n
\n \n \n First Level \n Draft Eligibility Effects in Current $ \n \n \n Second Level \n FICA Earnings \n Adjusted FICA Earnings \n Total W-2 Earnings \n P(V|eligible) - P(V|ineligible) \n Service Effect in 1978 $ \n \n \n Cohort \n Year \n Statistic \n \n \n \n \n 1950 \n 1981 \n Value \n 534.5 \n 654.0 \n 802.6 \n 0.06 \n 7780.5 \n \n \n Standard Error \n 413.6 \n 495.2 \n 524.6 \n 0.057 \n 5891.3 \n \n \n 1982 \n Value \n 285.2 \n 335.4 \n 326.0 \n 3758.5 \n \n \n Standard Error \n 461.3 \n 529.8 \n 609.0 \n 5937.0 \n \n \n 1983 \n Value \n 96.1 \n 169.1 \n 315.5 \n 1836.3 \n \n \n Standard Error \n 512.6 \n 551.6 \n 720.0 \n 5990.4 \n \n \n 1984 \n Value \n -76.9 \n -65.1 \n -287.4 \n -677.8 \n \n \n Standard Error \n 548.2 \n 601.9 \n 804.1 \n 6269.8 \n \n \n 1951 \n 1981 \n Value \n 313.2 \n 401.5 \n 416.0 \n 0.05 \n 5760.5 \n \n \n Standard Error \n 419.2 \n 446.6 \n 745.2 \n 0.06 \n 6407.4 \n \n \n 1982 \n Value \n 175.5 \n 228.1 \n -244.3 \n 3081.9 \n \n \n Standard Error \n 471.6 \n 524.4 \n 647.8 \n 7087.0 \n \n \n 1983 \n Value \n 419.6 \n 398.9 \n 254.3 \n 5224.8 \n \n \n Standard Error \n 538.2 \n 558.8 \n 767.6 \n 7318.6 \n \n \n 1984 \n Value \n -223.2 \n -293.5 \n -718.6 \n -3687.0 \n \n \n Standard Error \n 562.9 \n 598.1 \n 771.6 \n 7513.4 \n \n \n 1952 \n 1981 \n Value \n -305.9 \n -316.5 \n -272.4 \n 0.016 \n -14104.0 \n \n \n Standard Error \n 429.1 \n 454.8 \n 492.9 \n 0.061 \n 20262.8 \n \n \n 1982 \n Value \n -262.6 \n -502.6 \n -160.2 \n -21092.7 \n \n \n Standard Error \n 476.8 \n 524.1 \n 590.0 \n 21993.9 \n \n \n 1983 \n Value \n -177.3 \n -275.9 \n -53.6 \n -11221.1 \n \n \n Standard Error \n 531.5 \n 546.6 \n 643.5 \n 22235.2 \n \n \n 1984 \n Value \n -123.4 \n -99.8 \n -288.1 \n -3892.0 \n \n \n Standard Error \n 568.6 \n 600.3 \n 721.0 \n 23420.2 \n \n \n
\n
\nNote: The results are again a bit different to those in the paper. The same is the case, though, in the replication code my replication is building up on.\n
\n\n\n```python\ntable4 = get_table4(data_cwhsc_new)\np_value_star(table4[\"white\"], (slice(None), slice(None), [\"Value\", \"Standard Error\"]), (slice(None)))\n```\n\n\n\n\n\n\n
\n \n \n FICA Taxable Earnings \n Adjusted FICA Earnings \n Total W-2 Compensation \n \n \n Model \n Cohort \n Statistic \n \n \n \n \n Model 1 \n 1950 \n Value \n -1709.2 \n -2093.7 \n -1895 \n \n \n Standard Error \n 946.8 \n 1109.2 \n 1336.9 \n \n \n 1951 \n Value \n -1457.1 \n -1983.7 \n -2431.4* \n \n \n Standard Error \n 954.7 \n 1036.5 \n 1155.4 \n \n \n 1952 \n Value \n -1724.0* \n -1943.0* \n -2058.7* \n \n \n Standard Error \n 863.3 \n 927.5 \n 1004.8 \n \n \n 1953 \n Value \n 1223.8 \n 900.7 \n -488.6 \n \n \n Standard Error \n 3232.5 \n 3506.6 \n 3947.4 \n \n \n Chi Squared \n 578.3 \n 630.3 \n 569.5 \n \n \n Model 2 \n 1950-53 \n Value \n -1562.9* \n -1920.4* \n -2094.5* \n \n \n Standard Error \n 521.7 \n 576.8 \n 649.1 \n \n \n Chi Squared \n 579.1 \n 631 \n 569.7 \n \n \n
\n
\n\n
\n \n \n FICA Taxable Earnings \n Adjusted FICA Earnings \n Total W-2 Compensation \n \n \n Model \n Cohort \n Statistic \n \n \n \n \n Model 1 \n 1950 \n Value \n 3893.7 \n 3871.9 \n 5711.8 \n \n \n Standard Error \n 5355.1 \n 6246.9 \n 7206.5 \n \n \n 1951 \n Value \n -891.3 \n -333.4 \n 2609.0 \n \n \n Standard Error \n 4399.6 \n 4667.1 \n 4887.1 \n \n \n 1952 \n Value \n -3182.9 \n -3457.7 \n -3068.0 \n \n \n Standard Error \n 3994.9 \n 4194.9 \n 4222.7 \n \n \n 1953 \n Value \n -5928.3 \n -8571.5 \n -6325.8 \n \n \n Standard Error \n 10302.3 \n 10652.6 \n 11393.0 \n \n \n Chi Squared \n 616.7 \n 681.7 \n 693.6 \n \n \n Model 2 \n 1950-53 \n Value \n -643.3 \n -999.7 \n 367.8 \n \n \n Standard Error \n 2406.8 \n 2602.6 \n 2733.8 \n \n \n Chi Squared \n 618.4 \n 683.4 \n 695.6 \n \n \n
\n
here .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n```\n\n\n\nToggle cell visibility here .\n\n\n\n```python\n%matplotlib notebook\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sym\nimport scipy.signal as signal\nfrom ipywidgets import widgets, interact\n```\n\n## PID krmilnik - zaprtozančni sistem\n\nProporcionalno-integrirni-diferencirni (PID) krmilni algoritem je najpogosteje uporabljen krmilni algoritem. Njegovo prenosno funkcijo zapišemo kot:\n\n\\begin{equation}\n P(s)=K_p \\cdot \\left( 1 + \\frac{1}{T_i s} + T_d s \\right).\n\\end{equation}\n\nPrenosna funkcija je sestavljena iz vsote proporcionalne, integrirne in diferencirne komponente. Ni nujno, da so v izbranem krmilniku prisotne vse tri komponente; če ni diferencirne ali integrirne komponente, govorimo tako o PI oz. PD krmilniku. V tem interaktivnem primeru je prikazan odziv P, Pi, PD in PID krmilnika na enotsko skočno, enotsko impulzno in sinusno funkcijo ter enotsko rampo. Krmilnik je v tem primeru del krmilnega sistema s povratno zvezo. Objekt je lahko proporcionalni objekt ničtega, prvega ali drugega reda, ali pa integrirni objekt ničtega ali prvega reda. \n\nSpodnji grafi prikazujejo.\n1. Odziv zaprtozančnega sistema na izbran vstopni signal, izbran tip objekta in izbrani krmilnik (levi graf).\n2. Lego ničel in polov prenosne funkcije rezultirajočega zaprtozancnega sistema.\n\n---\n\n### Kako upravljati s tem interaktivnim primerom?\n1. Izberi vstopni signal s preklapljanjem med *enotsko skočno funkcijo*, *enotsko impulzno funkcijo*, *enotsko rampo* in *sinusno funkcijo*.\n2. Izberi tip objekta: *P0* (proporcionalni objekt ničtega reda), *P1* (proporcionalni objekt prvega reda), *I0* (integrirni objekt ničtega reda) ali *I1* (integrirni objekt prvega reda). Prenosna funkcija objekta P0 je $k_p$ (v tem interaktivnem primeru $k_p=2$), PI objekta $\\frac{k_p}{\\tau s+1}$ (v tem interaktivnem primeru $k_p=1$ and $\\tau=2$), IO objekta $\\frac{k_i}{s}$ (v tem interaktivnem primeru $k_i=\\frac{1}{10}$) in I1 objekta $\\frac{k_i}{s(\\tau s +1)}$ (v tem interaktivnem primeru $k_i=1$ in $\\tau=10$).\n3. Izberi tip krmilnega algoritma s klikom na *P*, *PI*, *PD* ali *PID* gumb.\n4. Z uporabo drsnikov spreminjaj vrednosti koeficientov proporcionalnega ($K_p$), integrirnega ($T_i$) in diferencirnega ($T_d$) ojačnja. \n5. Z uporabo drsnika $t_{max}$ lahko spreminjaš interval vrednosti prikazanih na x osi.\n\n\n\n\n```python\nA = 10\na=0.1\ns, P, I, D = sym.symbols('s, P, I, D')\n\nobj = 1/(A*s)\nPID = P + P/(I*s) + P*D*s#/(a*D*s+1)\nsystem = obj*PID/(1+obj*PID)\nnum = [sym.fraction(system.factor())[0].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system.factor())[0], gen=s)))]\nden = [sym.fraction(system.factor())[1].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system.factor())[1], gen=s)))]\n\n# make figure\nfig = plt.figure(figsize=(9.8, 4),num='PID krmilnik - zaprtozančni sistem')\nplt.subplots_adjust(wspace=0.3)\n\n# add axes\nax = fig.add_subplot(121)\nax.grid(which='both', axis='both', color='lightgray')\nax.set_title('Časovni odziv')\nax.set_xlabel('$t$ [s]')\nax.set_ylabel('vhod, izhod')\nax.axhline(linewidth=.5, color='k')\nax.axvline(linewidth=.5, color='k')\n\nrlocus = fig.add_subplot(122)\n\n\ninput_type = 'enotska skočna funkcija'\n\n# plot step function and responses (initalisation)\ninput_plot, = ax.plot([],[],'C0', lw=1, label='vstopni signal')\nresponse_plot, = ax.plot([],[], 'C1', lw=2, label='izstopni signal')\nax.legend()\n\n\n\n\nrlocus_plot, = rlocus.plot([], [], 'r')\n\nplt.show()\n\ndef update_plot(KP, TI, TD, Time_span):\n global num, den, input_type\n \n num_temp = [float(i.subs(P,KP).subs(I,TI).subs(D,TD)) for i in num]\n den_temp = [float(i.subs(P,KP).subs(I,TI).subs(D,TD)) for i in den]\n system = signal.TransferFunction(num_temp, den_temp)\n zeros = np.roots(num_temp)\n poles = np.roots(den_temp)\n \n rlocus.clear()\n rlocus.scatter([np.real(i) for i in poles], [np.imag(i) for i in poles], marker='x', color='g', label='pol')\n rlocus.scatter([np.real(i) for i in zeros], [np.imag(i) for i in zeros], marker='o', color='g', label='ničla')\n rlocus.set_title('Diagram lege ničel in polov')\n rlocus.set_xlabel('Re')\n rlocus.set_ylabel('Im')\n rlocus.grid(which='both', axis='both', color='lightgray')\n \n time = np.linspace(0, Time_span, 300)\n \n if input_type == 'enotska skočna funkcija':\n u = np.ones_like(time)\n u[0] = 0\n time, response = signal.step(system, T=time)\n elif input_type == 'enotska impulzna funkcija':\n u = np.zeros_like(time)\n u[0] = 10\n time, response = signal.impulse(system, T=time)\n elif input_type == 'sinusna funkcija':\n u = np.sin(time*2*np.pi)\n time, response, _ = signal.lsim(system, U=u, T=time)\n elif input_type == 'enotska rampa':\n u = time\n time, response, _ = signal.lsim(system, U=u, T=time)\n else:\n raise Exception(\"Error in the program. Please restart simulation.\")\n \n response_plot.set_data(time, response)\n input_plot.set_data(time, u)\n \n rlocus.axhline(linewidth=.3, color='k')\n rlocus.axvline(linewidth=.3, color='k')\n rlocus.legend()\n \n ax.set_ylim([min([np.min(u), min(response),-.1]),min(100,max([max(response)*1.05, 1, 1.05*np.max(u)]))])\n ax.set_xlim([-0.1,max(time)])\n\n plt.show()\n\ncontroller_ = PID\nobject_ = obj\n\ndef calc_tf():\n global num, den, controller_, object_\n system_func = object_*controller_/(1+object_*controller_)\n \n num = [sym.fraction(system_func.factor())[0].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func.factor())[0], gen=s)))]\n den = [sym.fraction(system_func.factor())[1].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func.factor())[1], gen=s)))]\n update_plot(Kp_widget.value, Ti_widget.value, Td_widget.value, time_span_widget.value)\n\ndef transfer_func(controller_type):\n global controller_\n proportional = P\n integral = P/(I*s)\n differential = P*D*s/(a*D*s+1)\n if controller_type =='P':\n controller_func = proportional\n Kp_widget.disabled=False\n Ti_widget.disabled=True\n Td_widget.disabled=True\n elif controller_type =='PI':\n controller_func = proportional+integral\n Kp_widget.disabled=False\n Ti_widget.disabled=False\n Td_widget.disabled=True\n elif controller_type == 'PD':\n controller_func = proportional+differential\n Kp_widget.disabled=False\n Ti_widget.disabled=True\n Td_widget.disabled=False\n else:\n controller_func = proportional+integral+differential\n Kp_widget.disabled=False\n Ti_widget.disabled=False\n Td_widget.disabled=False\n \n controller_ = controller_func\n calc_tf()\n \ndef transfer_func_obj(object_type):\n global object_\n if object_type == 'P0':\n object_ = 2\n elif object_type == 'P1':\n object_ = 1/(2*s+1) \n elif object_type == 'I0':\n object_ = 1/(10*s)\n elif object_type == 'I1':\n object_ = 1/(s*(10*s+1))\n calc_tf()\n\nstyle = {'description_width': 'initial'}\n\ndef buttons_controller_clicked(event):\n controller = buttons_controller.options[buttons_controller.index]\n transfer_func(controller)\nbuttons_controller = widgets.ToggleButtons(\n options=['P', 'PI', 'PD', 'PID'],\n description='Izberi tip krmilnega algoritma:',\n disabled=False,\n style=style)\nbuttons_controller.observe(buttons_controller_clicked)\n\ndef buttons_object_clicked(event):\n object_ = buttons_object.options[buttons_object.index]\n transfer_func_obj(object_)\nbuttons_object = widgets.ToggleButtons(\n options=['P0', 'P1', 'I0', 'I1'],\n description='Izberi tip objekta:',\n disabled=False,\n style=style)\nbuttons_object.observe(buttons_object_clicked)\n\ndef buttons_input_clicked(event):\n \n global input_type\n input_type = buttons_input.options[buttons_input.index]\n update_plot(Kp_widget.value, Ti_widget.value, Td_widget.value, time_span_widget.value)\nbuttons_input = widgets.ToggleButtons(\n options=['enotska skočna funkcija','enotska impulzna funkcija', 'enotska rampa', 'sinusna funkcija'],\n description='Izberi vstopni signal:',\n disabled=False,\n style = {'description_width': 'initial','button_width':'180px'})\nbuttons_input.observe(buttons_input_clicked)\n \nKp_widget = widgets.IntSlider(value=10,min=1,max=50,step=1,description=r'\\(K_p\\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.1d')\nTi_widget = widgets.FloatLogSlider(value=1.,min=-3,max=1.1,step=.001,description=r'\\(T_{i} \\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.3f')\nTd_widget = widgets.FloatLogSlider(value=1.,min=-3,max=1.1,step=.001,description=r'\\(T_{d} \\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.3f')\n\ntime_span_widget = widgets.FloatSlider(value=10.,min=.5,max=50.,step=0.1,description=r'\\(t_{max} \\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.1f')\n\ntransfer_func(buttons_controller.options[buttons_controller.index])\ntransfer_func_obj(buttons_object.options[buttons_object.index])\n\ndisplay(buttons_input)\ndisplay(buttons_object)\ndisplay(buttons_controller)\n\ninteract(update_plot, KP=Kp_widget, TI=Ti_widget, TD=Td_widget, Time_span=time_span_widget);\n```\n\n\n \n\n\n\n\n\n\n\n ToggleButtons(description='Izberi vstopni signal:', options=('enotska skočna funkcija', 'enotska impulzna funk…\n\n\n\n ToggleButtons(description='Izberi tip objekta:', options=('P0', 'P1', 'I0', 'I1'), style=ToggleButtonsStyle(de…\n\n\n\n ToggleButtons(description='Izberi tip krmilnega algoritma:', options=('P', 'PI', 'PD', 'PID'), style=ToggleBut…\n\n\n\n interactive(children=(IntSlider(value=10, description='\\\\(K_p\\\\)', max=50, min=1, readout_format='.1d'), Float…\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "10b74bc8bf806bd5614ae12990e3db847ee274ad", "size": 135643, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_si/examples/02/.ipynb_checkpoints/TD-16-PID_krmilnik_zaprtozancni_sistem-checkpoint.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_si/examples/02/TD-16-PID_krmilnik_zaprtozancni_sistem.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_si/examples/02/TD-16-PID_krmilnik_zaprtozancni_sistem.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 112.194375517, "max_line_length": 83027, "alphanum_fraction": 0.7885921131, "converted": true, "num_tokens": 3644, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.40356685373537454, "lm_q2_score": 0.28776782797747225, "lm_q1q2_score": 0.11613355694313096}}
{"text": "Probabilistic Programming and Bayesian Methods for Hackers \n========\n\nWelcome to *Bayesian Methods for Hackers*. The full Github repository is available at [github/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers](https://github.com/CamDavidsonPilon/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers). The other chapters can be found on the project's [homepage](https://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/). We hope you enjoy the book, and we encourage any contributions!\n\n#### Looking for a printed version of Bayesian Methods for Hackers?\n\n_Bayesian Methods for Hackers_ is now a published book by Addison-Wesley, available on [Amazon](http://www.amazon.com/Bayesian-Methods-Hackers-Probabilistic-Addison-Wesley/dp/0133902838)! \n\n\n\nChapter 1\n======\n***\n\nThe Philosophy of Bayesian Inference\n------\n \n> You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assumes that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n#### Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\" )\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to } )\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```python\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json, matplotlib\n s = json.load( open(\"../styles/bmh_matplotlibrc.json\") )\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 1000]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials) / 2, 2, k + 1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials) - 1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$ pass. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```python\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2 * p / (1 + p), color=\"#348ABD\", lw=3)\n# plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2 * (0.2) / 1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Is my code bug-free?\")\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```python\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1. / 3, 2. / 3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0 + 0.25, .7 + 0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.ylim(0,1)\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n## Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n#### Expected Value\nExpected value (EV) is one of the most important concepts in probability. The EV for a given probability distribution can be described as \"the mean value in the long run for many repeated samples from that distribution.\" To borrow a metaphor from physics, a distribution's EV acts like its \"center of mass.\" Imagine repeating the same experiment many times over, and taking the average over each outcome. The more you repeat the experiment, the closer this average will become to the distributions EV. (side note: as the number of repeated experiments goes to infinity, the difference between the average outcome and the EV becomes arbitrarily small.)\n\n### Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots, \\; \\; \\lambda \\in \\mathbb{R}_{>0} $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```python\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [0.1, 3, 6, 7]\ncolours = [\"#348ABD\", \"#A60628\", \"#A01212\", \"#B15555\"]\nfor i,j in zip(lambda_, colours):\n plt.bar(a, poi.pmf(a, i), color=j,\n label=\"$\\lambda = %.1f$\" % i, alpha=0.60,\n edgecolor=j, lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\")\n```\n\n### Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```python\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1, 3]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1. / l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1. / l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0, 1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n### But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```python\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC\n-----\n\nPyMC is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC is so cool.\n\nWe will model the problem above using PyMC. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC code is easy to read. The only novel thing should be the syntax, and I will interrupt the code to explain individual sections. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables:\n\n\n```python\nimport pymc as pm\n\nalpha = 1.0 / count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\nlambda_1 = pm.Exponential(\"lambda_1\", alpha)\nlambda_2 = pm.Exponential(\"lambda_2\", alpha)\n\ntau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data)\n```\n\nIn the code above, we create the PyMC variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC's *stochastic variables*, so-called because they are treated by the back end as random number generators. We can demonstrate this fact by calling their built-in `random()` methods.\n\n\n```python\nprint(\"Random output:\", tau.random(), tau.random(), tau.random())\n```\n\n Random output: 52 12 49\n\n\n\n```python\n@pm.deterministic\ndef lambda_(tau=tau, lambda_1=lambda_1, lambda_2=lambda_2):\n out = np.zeros(n_count_data)\n out[:tau] = lambda_1 # lambda before tau is lambda1\n out[tau:] = lambda_2 # lambda after (and including) tau is lambda2\n return out\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. Note that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n`@pm.deterministic` is a decorator that tells PyMC this is a deterministic function. That is, if the arguments were deterministic (which they are not), the output would be deterministic as well. Deterministic functions will be covered in Chapter 2. \n\n\n```python\nobservation = pm.Poisson(\"obs\", lambda_, value=count_data, observed=True)\n\nmodel = pm.Model([observation, lambda_1, lambda_2, tau])\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `value` keyword. We also set `observed = True` to tell PyMC that this should stay fixed in our analysis. Finally, PyMC wants us to collect all the variables of interest and create a `Model` instance out of them. This makes our life easier when we retrieve the results.\n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n# Mysterious code to be explained in Chapter 3.\nmcmc = pm.MCMC(model)\nmcmc.sample(40000, 10000, 1)\n```\n\n [-----------------100%-----------------] 40000 of 40000 complete in 4.7 sec\n\n\n```python\nlambda_1_samples = mcmc.trace('lambda_1')[:]\nlambda_2_samples = mcmc.trace('lambda_2')[:]\ntau_samples = mcmc.trace('tau')[:]\n```\n\n\n```python\nfigsize(12.5, 10)\n# histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", density=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", density=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data) - 20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\")\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\n# type your code here.\nprint(\"{} {} \".format(lambda_1_samples.mean(), lambda_2_samples.mean()))\n```\n\n 17.750529345875638 22.709824130540305 \n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\n# type your code here.\n(1 - np.mean(lambda_1_samples/lambda_2_samples) ) * 100\n```\n\n\n\n\n 21.71608702288387\n\n\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\n# type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg/).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Patil, A., D. Huard and C.J. Fonnesbeck. 2010. \nPyMC: Bayesian Stochastic Modelling in Python. Journal of Statistical \nSoftware, 35(4), pp. 1-81. \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\n\n\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "07ccfbf27df164ac7aa215940c68753640a6ae5d", "size": 889424, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_stars_repo_name": "TudorAndrei/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "b596c3e32333ef382922c046ae506caa80646a23", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_issues_repo_name": "TudorAndrei/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "b596c3e32333ef382922c046ae506caa80646a23", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_forks_repo_name": "TudorAndrei/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "b596c3e32333ef382922c046ae506caa80646a23", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 820.5018450185, "max_line_length": 189489, "alphanum_fraction": 0.7339457896, "converted": true, "num_tokens": 11708, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38491214448393346, "lm_q2_score": 0.3007455852086007, "lm_q1q2_score": 0.11576062814671803}}
{"text": " **Chapter 3: [Imaging](Ch3-Imaging.ipynb)** \n\n\n **[Analysis of Transmission Electron Microscope Data](_Analysis_of_Transmission_Electron_Microscope_Data.ipynb)** \n\n\nby Gerd Duscher, 2019\n\nMicroscopy Facilities\n\n\n\n\n\n\nThe shift of the edges as above can be caused by the intial and/or the final states.\n\n### Band gap \nThe band gap changes are treated in the solid state theory of band structure and are, therefore, well covered in other textbooks. The trend is that with increased oxidation (or more general increased electronegativity of the reaction partner as in the series: B, C, N, O), the band gap opens and the edge shifts to higher energies. \nThis is seen in the figure above, where the onset of the Si-L$_{2,3}$ edge shifts to higher energies with Pauli electron--negativity of the reaction partner.\n\n\nIn fact, one can monitor band gap changes with stoichiometry at interfaces by the shift of the edge.\nPlease be aware that we see only the shift of the conduction band bottom and not the whole band gap change. This effect of the band gap is obvious between Si and SiO$_2$, where the edge shifts by about 6.5 eV.\n\n### Core-level shift\nThe initial state, the ``core-level``, can also shift, for example after oxidation. Some electrons will transfer to an anion (for example oxygen) and less electrons are available to fill the band structure. This is shown below for the case of Cu and its two oxides Cu$_2$O and CuO.\n\n\nThe more electrons transfer to oxygen for the ionic bonding of these materials, the more the edges shift to lower energies, even though a band gap opens up. The opening up of the band gap will cause a shift too higher energies and counteracts the effect of ionization. Due to lower electron densities, at the Cu atoms in the oxides, the core levels are assumed to shift to higher energies (see below) and compensate a little for the effect.\n\n>\n> \n>\n\n\nThe core-level shift is generally a small effect. This core states react to increase of electron density at the atom site with a decrease and vice versa. Simplified , we can think of the core level electrons getting repulsed from an increased electron density (through Coulomb interaction) and pushed closer (lower in energy) to the core.\n\n\n\n```python\nCu_L_reference_spectra = eels.get_spectrum_eels_db(element='Cu',edge='L2,3')\n```\n\n Cu_Cu_L3_Y_Kihn_124\n Cu2O_Cu_L3_Y_Kihn_129\n Profile Of Cu4O3-Cu L23\n CuO_Cu_L3_Y_Kihn_127\n found 4 spectra in EELS database)\n\n\n\n```python\nplt.figure()\n\nfor name, spectrum in Cu_L_reference_spectra.items(): \n if 'Cu_Cu_L3_Y_Kihn_124' in spectrum['TITLE']:\n plt.plot(spectrum['enery_scale'],spectrum['data']/np.max(spectrum['data']), label = 'Cu-L$_{2,3}$: Cu')\n if 'CuO_Cu_L3_Y_Kihn_127' in spectrum['TITLE']:\n plt.plot(spectrum['enery_scale'],spectrum['data']/np.max(spectrum['data']), label = 'Cu-L$_{2,3}$: CuO')\n if 'Cu2O_Cu_L3_Y_Kihn_129' in spectrum['TITLE']:\n plt.plot(spectrum['enery_scale'],spectrum['data']/np.max(spectrum['data']), label = 'Cu-L$_{2,3}$: Cu$_2$O')\n\nplt.legend();\nplt.xlim(910, 980)\n\n```\n\n\n \n\n\n\n\n\n\n\n\n\n (910.0, 980.0)\n\n\n\nThe case of the oxidized Cu where the slightly oxidized Cu$_2$O does shift to slighly lower energies compared to pure Cu, \nthe shift to lower energies due to ionic bonding is a little larger than the opening of the band gap and the core level shift to higher energies (further away from the nucleus) because of less Coulomb repulsion from the valence electrons.\n\nThis effect is even more pronounced for CuO with an larger band gap than Cu$_2$O.\n\nIn the figure below we see that the Si-L$_{3,2}$ edge shifts to higher energies with increased Ge content, when the spectra are taken from different locations at the diffuse Si - Ge interface. Intuitively, we would expect a shift to lower energies, because the band gap of SiGe alloys and of Ge is smaller than Si.\n\n\n\n\n\n*We see that as we acquire spectra at the diffuse interface between Si and Ge, that the Si-L${_3,2}$ edge shifts to higher energies. This is surprising as SiGe and Ge posses a smaller band gap than Si and one would expect the opposite.*\n\nThis shift can be explained by a shift of core levels. An all electron calculations can determine the 2p$_{3/2}$ core levels of an atom in a compound which is shown for Si-Ge and Si-GaAs alloys in the figure below. The calculations show that there is a core level shift to lower energies with increased Ge and GaAs content. Ge and GaAs will add additional electrons to the electronic structure and the Coulomb repulsion between core level electrons and valence electrons will increase, pushing the core levels to lower energies. \n\n\n\n*All electron ab initio calculations of the core level states for Si-Ge and Si-GaAs alloys with different composition. The calculations show an 2p$_{3/2}$ core level shift to lower energies with deviation of composition from pure Si (on the left).*\n\n\nThe shift of the core--levels to lower energies will increase the distance between core--level and conduction band bottom, which results in a simple picture in a shift to higher energies. We see that for pure Si, the 2p$_{3/2}$ core level is at about 89 eV but the edge is at 99.8 eV. The difference in energy is caused by relaxation of valence and core electrons. Effectively, we measure with the EELS edge onset the energy difference between an excited atom and an atom in its ground state.\n\nAll electrons will relax according to the overall electron density at the atom sites and the calculated core--level shifts can not be used for predicting the edge shifts. However, these calculations can explain the physical origin of the edge shift.\n\n### Conclusion\nIn summation, we can say that the following effects (strongest first, weakest last) cause a chemical shift:\n\n- band gap opening\n- ionic bonding\n- core level shift\n\nAll of these effects can be present at once, but usually only one dominates the chemical shift.\n\n\n## White Line\n\nIn this section, we try to analyze a distinct feature of the transition metal elements. The d-states of transition metal elements form a very flat band in the band structure. This flat band, creates a strong peak in the density of states. This analysis is based on the following simplification:\n\nIn the figure below, we see a s or p free electron like band in the general shape of a parabola, This parabola gives rise to a saw tooth like feature in the density of states (DOS) because flat bands have a higher density of states than steep ones. The DOS of the conduction band (above the Fermi level) is closely related to our EELS spectra. A flat d-band will cause a very prominent peak, a so called white line (in the age of photographic recording, these peaks appeared as white lines).\n\n\n\n *A schematic of the relationship of density of states (DOS on the left) and band structure of a transition metal element on the right). The s and p free electron like bands (parabola) give rise to saw tooth like feature in the DOS and the flat d bands (red) cause a sharp peak in the DOS.*\n \nSince these d-bands are so prominent we can easily separate them from the rest. In figure \\ref{fig:Ti-whiteline} we use the calculated cross--section as a model of the s and p free electron like states. After a subtraction, we get the pure d-band contribution.\n\n\n*We use the cross section of the Ti-L$_{2,3}$ edge (green) as a model for the free electron gas and subtract it from the experimental Ti-L$_{2,3}$ edge (red). The residual peaks (blue) can be analyzed as pure d-states. The two double peaks of the Ti-L$_{2,3}$ edge indicate that there is some structure to the d-bands (here crystal field splitting).*\n\nA simple analysis of the white line ratios of Ti-L$_3$ to Ti-L$_2$ of SrTiO$_3$ yields a intensity ratio of 242 / 314 = 0.8. However, just considering the initial states (and assuming the transition probability ( or more accurately the transition matrix elements) are the same for both edges) with 4 electrons in p$_{3/2}$ and 2 electrons in p$_{1/2}$ would let us expect a ration of 2 to 1. \n\n>Please, note that both the Ti-L$_3$ and Ti-L$_2$ edge are split in two. We will discuss this crystal field splitting in chapter \\ref{sec:Titanium} as an ELNES feature. Here we just consider the sum over the the whole Ti-L$_3$ or/and Ti-L$_2$ and ignore this splitting.\n\nThe deviation from the 2 : 1 white line ratio is assumed to be caused by J-J coupling, and is, therefore, symmetry dependent. The anomalous white line ratios have been used to determine valency of transition elements in compounds. Physically this approach is on shaky ground, because we do not know all the reasons for the change in the ratios, it has, however, been shown to be reliable for binary metallic alloys.\n\nFortunately, there is a easier method (from the physical point of view). We compare the total amount of white line intensities (which corresponds to the empty d-states) and normalize them by the free-electron gas like intensity beyond the white lines. \n\nWe use the method of Okamoto et al. \\cite{Okamoto-Disko1992}. \n\n\nThe energy-window for the free-electron like part of the edge can be chosen arbitrarily and consistently.\nFollowing Okamoto et al., a 50 eV integration window should be used 50 eV beyond the edge onset. These will allow to compare the results to values in the literature. \nThe edge has to be taken in very thin areas and if possible corrected for single scattering distribution, because otherwise the free electron like part contains plasmon contributions, which change the analysis.\n\nFor the above spectrum in the figure above, we get for the white line / free electron gas ratio (50 eV - 50 eV beyond edge onset) = 556 / 974 = 0.57. Ti in SrTiO$_3$ can be considered as Ti$^{4+}$ with no electrons in the d-bands, but using this ratio in the paper of Okamoto et al. would yield a d band occupancy of 4 as in a metal. The difference may lay in the usage of a Hatree-Slater X-section for the analysis while Okamoto et al. use a hydrogenic one. Also, the SrTiO$_3$ spectrum was presumably taken under completely different acquisition conditions than Okamoto's spectra. \n\\\nFor example, the SrTiO$_3$ spectrum was not corrected for convergence angle, even though it was acquired in Z-contrast mode. Another source of error, is of course the background fit, which could change especially the free electron integration result. The fact that the SrTiO$_3$ spectrum was not corrected for single scattering distribution may also overestimate the free electron gas contribution, even though the spectrum was taken in a every thin area.\n\nFor TiO$_2$ spectrum of the core-loss atlas I get for the white line / free electron gas 256 / 494 = 0.52. TiO$_2$ contains also only Ti$^{4+}$. This is the level of agreement we can expect, if we use two spectra with completely different acquisition parameters. \n\n\nIn the plotof the Cu-L edges above, we can see that Cu has no empty d-states but with oxidation the d-bands get unoccupied and white lines appear. The more electrons get transferred to the oxygen neighbors, the more empty d-states and the more prominent the white lines will appear.\n\nThis analysis of the occupancy of d-states is extremely important for magnetic materials where the strength depends on the unpaired (d-band or f-band) electrons.\n\nThe same analysis can be done for the empty f bands of M--edges, which are also rather flat. Usually, the M$_{4,5}$ and the M$_{2,3}$ edges form doublets of white lines.\n\n\n\n\n## ELNES\n\nSo far, we have only interpreted distinct features of the shape of the ionization edges. A general approach is to look at the shape of the edges in total and use this shape as a kind of fingerprint for the interpretation. Another one is to try to understand the different features as means of electronic structure calculations of various sophistication. \n\nIn order to understand the different approaches ( and their level of confidence in the results), we will discuss the most important edges one by one.\n\nThe shape of the ELNES is closely related to the density of states of the conduction band. The next chapters discuss the basics for an electronic structure interpretation of ELNES\n\n\n\n### Transition matrix and electronic structure\nThe single scattering intensity of an ionization edge $J_k^1(E)$ is related to the band structure through Fermi's Golden Rule: The transition rate is proportional to the density of final states $N(E)$ multiplied with the square of an atomic transition matrix $M(E)$\n \n \\begin{equation} \\Large\n J_k^1(E) \\propto |M(E)|^2 N(E)\n \\end{equation} \n \n The transition matrix describes the transition probability between the core states and the final states (given by $N(E)$). Because the transition probability generally decreases with higher energies (above the edge threshold, the transition matrix gives the overall shape of the edge (sawtooth) and can be determined by atomic physics. \n \n\n The density of final states (conduction band) ($N(E)$) expresses the chemical environment and its symmetry. \n Because the core--levels are highly localized the final states $N(E)$ present the local density of states. This localization causes a different shape for different elements in the same compound, even if they are nearest neighbors (with a distance of only a few Angstrom). The $N(E)$ will of course be different for elements in materials with different (local) symmetry, coordination or chemical composition.\n \n### Life-time broadening\n For arbitrary excitations, the $N(E)$ is the joint density of states, which means a convolution of the initial and the final states. The density of final states $N(E)$ is broadened in the spectrum by the energy resolution of the experimental setup $\\delta E$ and the width of the initial state $\\Gamma_i$. $\\Gamma_i$ can be approximated with the uncertainty principle: \n \n \\begin{equation} \\Large\n \\Gamma_i \\pi_h \\approx \\hbar\n \\end{equation}\n\n The lifetime of the core -hole $\\pi_h$ is determined how fast the core--hole is filled and the additional energy is dissipated through emission of Auger electrons (for light elements) or X-ray photons (heavier atoms). The value of $\\Gamma_i$ depends on the threshold energy of the edge and is calculated to be around 0.1 and 2 eV for K-edges of the first 40 elements.\n \n\n Further broadening of the $N(E)$ is induced by the lifetime of the final states $\\pi_f$. The inelastic mean free path of the ejected electron is only a few nm (assuming a kinetic energy of less than 50eV). \n Using the free electron approximation ($E_{kin} = m_0 v^2 / 2$), we get for the energy broadening of the final states:\n \\begin{equation} \\Large\n \\Gamma_f \\approx \\frac {\\hbar}{\\pi_f} = \\frac{\\hbar v}{\\lambda_i } = \\frac{\\hbar}{\\lambda_i} \\sqrt{\\frac{2E_{kin}}{m_0}} \n \\end{equation}\n \n \n Since the inelastic mean free path $\\lambda_i$ varies inversely with kinetic energy $E_{kin}$ below 50 eV (and raises only slightly above 50 eV), the observed density of state structure is more and more broadened the further the distance from the onset. \n \n The next two chapters discuss the density of final states $N(E)$ and the transition matrix $M(E)$ in detail.\n \n\n### Dipole-selection rule\n\nAssuming a single electron approximation (and almost no electronic theory theory solves the many-particle problem fully) for the excitation, we can replace the many electron transition matrix elements with single electron matrix elements $M(\\vec{q},E)$.\n\n\\begin{equation} \\Large\nM(\\vec{q},E) = \n \\end{equation}\n \n with the initial wave function $|i> = \\phi_i$ and the complex conjugated final wave function $\n\n\n\n\n\n\n\n\n\n (275.0, 310.0)\n\n\n\nLooking at the bonding of carbon in molecular orbital theory or (its predecessor) Ligand--Field theory the non--hybridized p electron in graphite will form an occupied $\\pi$ bond and an unoccupied $\\pi^*$ bond. In figure \\ref{fig:C-K} we see that the unoccupied $\\pi^*$ state is visible in the graphite spectrum. \nIn diamond, there is no molecule like p electron and consequently there is no $\\pi$ or $\\pi^*$ bond. \nThe appearance of the $\\pi^*$ state in a carbon spectrum is used as a fingerprint for $sp_2$ hybridization. In the case of so called diamond like carbon, an amorphous carbon with $sp_2$ and $sp_3$ bonds, the quality (amount of $sp_3$ bonds) of the diamond like carbon can be assessed by the intensity of the $\\pi^*$ peak (or rather the lack of it).\n\nBoth spectra have a $\\sigma_1^*$ and $\\sigma_2^*$ peak which are associated with the molecule like s states.\nThe C-K edge should show only the p density of states due to the dipole selection rule. The $\\sigma^*$ states show up in the C-K edge because of these states are already related to the s-p like free electron gas density of states (s-p hybridization) above the edge. The $\\sigma^*$ states are the non-bonding states of the ( $sp_2$ or $sp_3$) hybridized states and are, therefore, present in any carbon compound.\n\nThe quantification of $sp_2$ versus $sp_3$ hybridization is also important in polymers (where the non hybridized p electron in a $sp_2$ configuration forms the conducting double bonds. In Buckminster fullerens (bucky balls) and carbon nanotubes the $sp_3$ hybridization is always associated with a defect (dislocation like), where a carbon atom has now 4 nearest neighbors.\n\n\n### Silicon\n\nThe calculation of the transition matrix $M(E)$ for \nthe Si-L$_{3,2}$ edge shows that the intensity of the ELNES consists almost exclusively of d-states. Less than 5\\% of the intensity is from the also dipole--allowed s-DOS. \n\nWe can, therefore, assume that only d-states form the Si-L$_{3,2}$ ELNES.\nThe spin orbit splitting of the initial p states is 0.7 eV, and this means that the L$_3$ and the L$_2$ are separated by 0.7 eV, which cannot be resolved with most instrumental setups. \nTo the calculated (local) d-DOS the same DOS has to be added (with a ratio of about 2:1) but shifted by 0.7 eV.\n \n\n*Comparison of experimental and theoretical data. While an effective mass exciton would explain the sharp raise, the effect is to small, the electronic structure calculation without core hole effect, placed at the correct onset, does not agree with the experiment.*\n\t\nThe edge onset of the Si-L$_{3,2}$ of pure Si should be at 100 eV without core-hole effects. A d--Dos calculated without influence of a core--hole is shown in figure \\ref{fig:Si-L-pure} beginning at this value. We can clearly see that this DOS of state cannot reproduce the experimental ELNES. From this disagreement between experiment and DOS without core-hole effect, we conclude that the \n\tcore-hole effects must be included.\n\t\nThe main feature of the Si-L$_{3,2}$ of pure Si is the extreme sharp raise of the edge at the onset.\nThis feature cannot be explained by the d-DOS calculated without core--hole effects, which raises not as steeply as the experimental ELNES.\n\t\nThis steep raise is another indication of the core--hole and must have its origin in an excitonic effect (an interaction of the excess electron in the conduction band an the hole in the core state).\nIn the figure above, the calculations of an effective mass electron (due to an state that is created just below the conduction band) is compared to the experimental ELNES. Such an effective mass electron must be considered delocalized. We see that the raise is steep enough to explain the experimental raise, we also see that the effect (intensity) is not change the ELNES.\n\n\t\nOnly the explicit inclusion of the core--hole or the Z+1 calculations in figure \\ref{fig:Si-L-pure2} can explain this steep onset. We can, therefore, conclude on localized excitonic enhancement of the states at the bottom of conduction band. This is a rather localized excitonic effect.\n\nWe can also see in the comparison of the explicit inclusion of the core-hole and the Z+1 approximation that both simulations lead to the same ELNES, however only the explicit core-hole calculation can predict the exact intensity (cross section) of the Si-L$_{3,2}$ edge.\n\nThe same calculations are also successful for SiO$_2$ (quartz) as can be seen in figure \\ref{fig:Si-L-sio2}. The experimental data show the spin--orbit splitting in the first peak, all other features are to smeared out to show a clear distinction between transitions originating from $2p_{3/2}$ and 2p$_1/2$.\nDue to the simple addition of the shifted spectra, the splitting in the first peak is reproduced rather easily and cannot be used for further analysis. Again, this edge is completely dominated by the local d-DOS. \n \n\n### Oxygen and Nitrogen\n\nOxygen and nitrogen edges are usually very similar. Here we will discuss mostly the oxygen edge, but this can be easily transferred to nitrogen.\n\nThe Si-SiO$_2$ interface shows oxygen deficiency in the oxide at the interface. In the following, I will show that the oxygen K edge ELNES cannot be used to probe the oxygen deficiency. Experimentally, the oxygen K edge has a chemical shift by about 1 eV. The structure of the edge is washed out at the interface as shown in figure . Higher spatial resolution experiments by Muller (nature 2003) show a completely structureless O-K edge. Simulation of the O-K edge show that this shift and the featureless structure is due to the dimer like structure (Si-O-Si) which is not avoidable at any Si-SiO$_2$ interface.\n\nAnother approach is the so called \"finger-print\" method. In this method, one compares edges from different but known materials and hopes that similar features are conclusive for different coordinations within the unknown material. This approach can be improved by using simulations of the ELNES of the edges as seen in the plot below.\n\n\n```python\nO_reference_spectra = eels.get_spectrum_eels_db(element='O',edge='K')\n```\n\n (La0_7,Sr0_3)MnO3_O_K_imhoff_229\n 8-pm\n Al2O3_Al_K_Flank_1xray\n Al2O3_(alpha)_Al_K_Stefan_Nufer_53\n AlPO4_Al_K_Flank_2xray\n B2O3_B_K_Karine_Varlot_8xray\n B2O3_B_K_Karine_Varlot_9xray\n 7-pm\n E113 250-2-cal-kgd-pm-dm\n e113 k-pm\n 255-1-pmmod\n CaCoO NT-2\n CaTiO3_Ti_L3_Saso_Sturm_133\n CoO_O_K_dominique_IMHOFF_235\n Cr2O3_(alpha)_O_K_Rik_Brydson_158\n Cu2O_O_K_Y_Kihn_130\n Profile Of Cu4O3-O-K\n CuO_O_K_Y_Kihn_126\n Fe2O3_(alpha)_O_K_A__Gloter,_A__Chen_201\n Fe2TiO5_Ti_L3_E_Fries_P_Perriat_36\n Fe3O4_O_K_A__Gloter,_A__Chen_205\n FeCO3_O_K_A__Gloter,_A__Chen_206\n FeOOH_O_K_A__Gloter,_A__Chen_204\n FeOOH__(alpha)_O_K_A__Gloter,_A__Chen_203\n FeOOH__(beta)_O_K_A__Gloter,_A__Chen_202\n lsmo2\n APL_article_LSMO_oxygen2\n APL_article_interface_oxygen2\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n LaCoO3_O_K_Irmgrad_Rom,_Ferdinand_Hofer_162\n MgCO3_O_K_Irmgard_Rom_43\n MgCO3_C_K_Irmgard_Rom_44\n MgO_O_K_Giovanni_Bertoni_112\n MgO_Mg_K_Giovanni_Bertoni_113\n MgO_O_K_dominique_IMHOFF_233\n MgO_Mg_K_dominique_IMHOFF_234\n Na2O_Na_K_Flank_34xray\n Nb2O5_Nb_M_David_Bach,_Wilfried_Sigle_215\n NbO2_Nb_M_David_Bach,_Wilfried_Sigle_217\n SiO2_Si_K_Flank_27xray\n SiO2_Si_K_Flank_28xray\n SiO2_Si_K_Flank_29xray\n Spectre centre EELSDB\n SrTiO3_O_K_imhoff_232\n srtio32\n APL_article_STO_oxygen2\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n y\n EELS Spectrum Image (high-loss)model from decomposition with 6 components\n TiO2_(amorphous)_O_K_Giovanni_Bertoni_106\n TiO2_(anatase)_O_K_Giovanni_Bertoni_103\n Y3Al5O12_O_K_Saso_Sturm_182\n Y3Al5O12_Al_K_Saso_Sturm_213\n Y4Al2O9_O_K_Saso_Sturm_178\n Y4Al2O9_Al_K_Saso_Sturm_179\n YAlO3_O_K_Saso_Sturm_186\n YAlO3_Al_K_Saso_Sturm_187\n ZnO_O_K_Wilfried_Sigle_169\n found 55 spectra in EELS database)\n\n\n\n```python\nO_reference_titles = ['SrTiO3_O_K_imhoff_232',\n 'MgO_O_K_Giovanni_Bertoni_112',\n 'ZnO_O_K_Wilfried_Sigle_169',\n 'Cr2O3_(alpha)_O_K_Rik_Brydson_158'\n ]\nO_reference_materials = ['SrTiO$_3$', 'MgO', 'ZnO', 'Cr$_2$O$_3$']\nplt.figure()\ni = 0\nfor name, spectrum in O_reference_spectra.items(): \n if spectrum['TITLE'] in O_reference_titles:\n plt.plot(spectrum['enery_scale'],spectrum['data']/np.max(spectrum['data']), label = 'O-K:'+O_reference_materials[i])\n i+=1\n \nplt.legend();\nplt.xlim(525,570)\n\n\n```\n\n\n \n\n\n\n\n\n\n\n\n\n (525.0, 570.0)\n\n\n\nA comparison hows that the cubic oxides MgO and MgAl$_2$O$_4$ (spinel structure) have a similar ELNES which differs from the ELNES from the rhombohedral oxide Al$_2$O$_3$.\n\n\nCorrelation effects of valence electrons cause the so called Hubbard band. These bands dominate the electronic structure in high T$_c$ semiconductors, giant magnet resistors and other materials with high correlations.\n\nIn the figure below, we see that such a correlation effect takes place in the giant magneto-resistor LaMnO$_3$ but not in the perovskite LaAlO$_3$, which does not have this splitting of the d bands (Al does not have d electrons but Mn has), a precondition for the formation of a Hubbard band.\n\t\n\n\n\n*The O-K edge in LaMnO$_3$ has a pre-peak that is interpreted as Hubbard band and is not present in LaAlO$_3$ even so it has the same structure.*\n\n\t\nThe same Hubbard band is visible in the high T$_c$ superconductor YBa$_2$Cu$_3$O$_{7-\\delta}$.\nIn figure \\ref{fig:O-K-YBCO-DL}, we see the probing of this Hubbard band at a dislocation in YBa$_2$Cu$_3$O$_{7-\\delta}$.\n\n\n\n*The O-K edge at a dislocation in YBa$_2$Cu$_3$O$_{7-\\delta}$ has less of the signature of a Hubbard band than far away in the bulk. This lack of holes in the dislocation disturbs the superconductivity and is utilized in grain boundaries for Josephson junctions but is detrimental in polycrystalline high T$_c$ wires.*\n\n\nThe prepeak that is caused by the Hubbard band is reduced in the vicinity of the dislocation and vanishes completely within the dislocation core. This lack of holes in the dislocation disturbs the superconductivity and is utilized in grain boundaries for Josephson junctions but is detrimental in polycrystalline high T$_c$ wires.\n \n\n## Spatial Resolution in EELS\n% images/spat-dif-resolution.jpg}\n\n### Methods to achieve spatial resolution\n- Spot Mode\n- Area Mode = Spatial Difference\n- Lines Scan Mode \n - Each Spot of Line one Spectrum\n - Each Segement of Line one Spectrum\n - Each Area of Line one Spectrum\n- Spectrum Imaging\n\n### Spot mode\n% {images/spat-dif-spot.jpg}\n\n### Spatial difference\n% images/spat-dif-spatdif1.jpg\n% images/spat-dif-spatdif2.jpg\n% images/spat-dif-spatdif3.jpg\n*EELS at Bi doped Cu grain boundary*\n% images/spat-dif-spatdif4.jpg\n% images/spat-dif-ls1.jpg\n*As segregation at Si/SiO$_2$ interface*\n% images/spat-dif-ls2.jpg\n*As segregation at Si/Sio$_2$ interface*\n\n### Energy Filtered Imaging (EFTEM) \n% images/spat-dif-eftem1.jpg}\n% images/spat-dif-eftem2.jpg}\n% images/spat-dif-eftem3.jpg}\n\n## Summary\n\nThe core--loss part of the electron energy--loss spectrum allows us to determine:\n- chemical composition\n- bonding\n- magnetic moment through ionic charge \n\n>\n>\twith high spatial resolution!!!\n>\n\n## Navigation\n- **Up Chapter 4: [Imaging](CH4_00-Spectroscopy.ipynb)** \n- **Back: [Analysis of Core-Loss](CH4_09-Analysis_Core_Loss.ipynb)** \n- **List of Content: [Front](../_MSE672_Intro_TEM.ipynb)** \n\n\n```python\n\n```\n", "meta": {"hexsha": "8d027c5fcc53fae6bb226b23b77845269f8a6437", "size": 810946, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Spectroscopy/CH4_10-ELNES.ipynb", "max_stars_repo_name": "ahoust17/MSE672-Introduction-to-TEM", "max_stars_repo_head_hexsha": "6b412a3ad07ee273428a95a7158aa09058d7e2ee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-01-22T18:09:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-26T20:17:34.000Z", "max_issues_repo_path": "Spectroscopy/CH4_10-ELNES.ipynb", "max_issues_repo_name": "ahoust17/MSE672-Introduction-to-TEM", "max_issues_repo_head_hexsha": "6b412a3ad07ee273428a95a7158aa09058d7e2ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Spectroscopy/CH4_10-ELNES.ipynb", "max_forks_repo_name": "ahoust17/MSE672-Introduction-to-TEM", "max_forks_repo_head_hexsha": "6b412a3ad07ee273428a95a7158aa09058d7e2ee", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 9, "max_forks_repo_forks_event_min_datetime": "2021-01-26T16:10:11.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T14:53:16.000Z", "avg_line_length": 135.4285237141, "max_line_length": 155375, "alphanum_fraction": 0.8174366727, "converted": true, "num_tokens": 14101, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4455295350395727, "lm_q2_score": 0.2598256436924554, "lm_q1q2_score": 0.11575999822565736}}
{"text": "# [Math-Bot] Siamese LSTM: Detecting duplicates\n\n\n\nAuthor: Alin-Andrei Georgescu 2021 \n\nWelcome to my notebook! It explores the Siamese networks applied to natural language processing. The model is intended to detect duplicates, in other words to check if two sentences are similar.\nThe model uses \"Long short-term memory\" (LSTM) neural networks, which are an artificial recurrent neural networks (RNNs). This version uses a custom embedding layer with weigths based on GloVe pretrained vectors.\n\n## Outline\n\n- [Overview](#0)\n- [Part 1: Importing the Data](#1)\n - [1.1 Loading in the data](#1.1)\n - [1.2 Converting a sentence to a tensor](#1.2)\n - [1.3 Understanding and building the iterator](#1.3)\n- [Part 2: Defining the Siamese model](#2)\n - [2.1 Understanding and building the Siamese Network](#2.1)\n - [2.2 Implementing Hard Negative Mining](#2.2)\n- [Part 3: Training](#3)\n- [Part 4: Evaluation](#4)\n- [Part 5: Making predictions](#5)\n\nNatural Language Processing Specialization .\n\n\n\"\nembeddings[pad] = np.zeros(300)\nembeddings_index[pad] = index\nindex += 1\n\nunk = \"\"\nembeddings[unk] = np.asarray([0.22418134, -0.28881392, 0.13854356, 0.00365387, -0.12870757, 0.10243822, 0.061626635, 0.07318011, -0.061350107, -1.3477012, 0.42037755, -0.063593924, -0.09683349, 0.18086134, 0.23704372, 0.014126852, 0.170096, -1.1491593, 0.31497982, 0.06622181, 0.024687296, 0.076693475, 0.13851812, 0.021302193, -0.06640582, -0.010336159, 0.13523154, -0.042144544, -0.11938788, 0.006948221, 0.13333307, -0.18276379, 0.052385733, 0.008943111, -0.23957317, 0.08500333, -0.006894406, 0.0015864656, 0.063391194, 0.19177166, -0.13113557, -0.11295479, -0.14276934, 0.03413971, -0.034278486, -0.051366422, 0.18891625, -0.16673574, -0.057783455, 0.036823478, 0.08078679, 0.022949161, 0.033298038, 0.011784158, 0.05643189, -0.042776518, 0.011959623, 0.011552498, -0.0007971594, 0.11300405, -0.031369694, -0.0061559738, -0.009043574, -0.415336, -0.18870236, 0.13708843, 0.005911723, -0.113035575, -0.030096142, -0.23908928, -0.05354085, -0.044904727, -0.20228513, 0.0065645403, -0.09578946, -0.07391877, -0.06487607, 0.111740574, -0.048649278, -0.16565254, -0.052037314, -0.078968436, 0.13684988, 0.0757494, -0.006275573, 0.28693774, 0.52017444, -0.0877165, -0.33010918, -0.1359622, 0.114895485, -0.09744406, 0.06269521, 0.12118575, -0.08026362, 0.35256687, -0.060017522, -0.04889904, -0.06828978, 0.088740796, 0.003964443, -0.0766291, 0.1263925, 0.07809314, -0.023164088, -0.5680669, -0.037892066, -0.1350967, -0.11351585, -0.111434504, -0.0905027, 0.25174105, -0.14841858, 0.034635577, -0.07334565, 0.06320108, -0.038343467, -0.05413284, 0.042197507, -0.090380974, -0.070528865, -0.009174437, 0.009069661, 0.1405178, 0.02958134, -0.036431845, -0.08625681, 0.042951006, 0.08230793, 0.0903314, -0.12279937, -0.013899368, 0.048119213, 0.08678239, -0.14450377, -0.04424887, 0.018319942, 0.015026873, -0.100526, 0.06021201, 0.74059093, -0.0016333034, -0.24960588, -0.023739101, 0.016396184, 0.11928964, 0.13950661, -0.031624354, -0.01645025, 0.14079992, -0.0002824564, -0.08052984, -0.0021310581, -0.025350995, 0.086938225, 0.14308536, 0.17146006, -0.13943303, 0.048792403, 0.09274929, -0.053167373, 0.031103406, 0.012354865, 0.21057427, 0.32618305, 0.18015954, -0.15881181, 0.15322933, -0.22558987, -0.04200665, 0.0084689725, 0.038156632, 0.15188617, 0.13274793, 0.113756925, -0.095273495, -0.049490947, -0.10265804, -0.27064866, -0.034567792, -0.018810693, -0.0010360252, 0.10340131, 0.13883452, 0.21131058, -0.01981019, 0.1833468, -0.10751636, -0.03128868, 0.02518242, 0.23232952, 0.042052146, 0.11731903, -0.15506615, 0.0063580726, -0.15429358, 0.1511722, 0.12745973, 0.2576985, -0.25486213, -0.0709463, 0.17983761, 0.054027, -0.09884228, -0.24595179, -0.093028545, -0.028203879, 0.094398156, 0.09233813, 0.029291354, 0.13110267, 0.15682974, -0.016919162, 0.23927948, -0.1343307, -0.22422817, 0.14634751, -0.064993896, 0.4703685, -0.027190214, 0.06224946, -0.091360025, 0.21490277, -0.19562101, -0.10032754, -0.09056772, -0.06203493, -0.18876675, -0.10963594, -0.27734384, 0.12616494, -0.02217992, -0.16058226, -0.080475815, 0.026953284, 0.110732645, 0.014894041, 0.09416802, 0.14299914, -0.1594008, -0.066080004, -0.007995227, -0.11668856, -0.13081996, -0.09237365, 0.14741232, 0.09180138, 0.081735, 0.3211204, -0.0036552632, -0.047030564, -0.02311798, 0.048961394, 0.08669574, -0.06766279, -0.50028914, -0.048515294, 0.14144728, -0.032994404, -0.11954345, -0.14929578, -0.2388355, -0.019883996, -0.15917352, -0.052084364, 0.2801028, -0.0029121689, -0.054581646, -0.47385484, 0.17112483, -0.12066923, -0.042173345, 0.1395337, 0.26115036, 0.012869649, 0.009291686, -0.0026459037, -0.075331464, 0.017840583, -0.26869613, -0.21820338, -0.17084768, -0.1022808, -0.055290595, 0.13513643, 0.12362477, -0.10980586, 0.13980341, -0.20233242, 0.08813751, 0.3849736, -0.10653763, -0.06199595, 0.028849555, 0.03230154, 0.023856193, 0.069950655, 0.19310954, -0.077677034, -0.144811], dtype='float32')\nembeddings_index[unk] = index\nindex += 1\n\nf = open(\"data/glove.6B.300d.txt\")\nfor line in f:\n values = line.split()\n word = values[0]\n coefs = np.asarray(values[1:], dtype=\"float32\")\n embeddings_index[word] = index\n index += 1\n embeddings[word] = coefs\nf.close()\n\nvocab_size = index + 1\nprint(\"Loaded %s word vectors.\" % vocab_size)\n```\n\nThen I split the data into a train and test set. The test set will be used later to evaluate the model.\n\n\n```python\nN_dups = len(data[data.is_duplicate == 1])\n\n# Take 90% of the duplicates for the train set\nN_train = int(N_dups * 0.9)\nprint(N_train)\n\n# Take the rest of the duplicates for the test set + an equal number of non-dups\nN_test = (N_dups - N_train) * 2\nprint(N_test)\n\ndata_train = data[: N_train]\n# Shuffle the train set\ndata_train = data_train.sample(frac=1)\n\ndata_test = data[N_train : N_train + N_test]\n# Shuffle the test set\ndata_test = data_test.sample(frac=1)\n\nprint(\"Train set: \", len(data_train), \"; Test set: \", len(data_test))\n\n# Remove the unneeded data to some memory\ndel(data)\n```\n\n\n```python\nS1_train_words = np.array(data_train[\"sentence1\"])\nS2_train_words = np.array(data_train[\"sentence2\"])\n\nS1_test_words = np.array(data_test[\"sentence1\"])\nS2_test_words = np.array(data_test[\"sentence2\"])\ny_test = np.array(data_test[\"is_duplicate\"])\n\ndel(data_train)\ndel(data_test)\n```\n\nAbove, you have seen that the model only takes the duplicated sentences for training.\nAll this has a purpose, as the data generator will produce batches $([s1_1, s1_2, s1_3, ...]$, $[s2_1, s2_2,s2_3, ...])$, where $s1_i$ and $s2_k$ are duplicate if and only if $i = k$.\n\nAn example of how the data looks is shown below.\n\n\n```python\nprint(\"TRAINING SENTENCES:\\n\")\nprint(\"Sentence 1: \", S1_train_words[0])\nprint(\"Sentence 2: \", S2_train_words[0], \"\\n\")\nprint(\"Sentence 1: \", S1_train_words[5])\nprint(\"Sentence 2: \", S2_train_words[5], \"\\n\")\n\nprint(\"TESTING SENTENCES:\\n\")\nprint(\"Sentence 1: \", S1_test_words[0])\nprint(\"Sentence 2: \", S2_test_words[0], \"\\n\")\nprint(\"is_duplicate =\", y_test[0], \"\\n\")\n```\n\nThe first step is to tokenize the sentences using a custom tokenizer defined below.\n\n\n```python\n# Create arrays\nS1_train = np.empty_like(S1_train_words)\nS2_train = np.empty_like(S2_train_words)\n\nS1_test = np.empty_like(S1_test_words)\nS2_test = np.empty_like(S2_test_words)\n```\n\n\n```python\ndef data_tokenizer(sentence):\n \"\"\"Tokenizer function - cleans and tokenizes the data\n\n Args:\n sentence (str): The input sentence.\n Returns:\n list: The transformed input sentence.\n \"\"\"\n \n if sentence == \"\":\n return \"\"\n\n sentence = tc.lower_all(sentence)[0]\n\n # Change tabs to spaces\n sentence = re.sub(r\"\\t+_+\", \" \", sentence)\n # Change short forms\n sentence = re.sub(r\"\\'ve\", \" have\", sentence)\n sentence = re.sub(r\"(can\\'t|can not)\", \"cannot\", sentence)\n sentence = re.sub(r\"n\\'t\", \" not\", sentence)\n sentence = re.sub(r\"I\\'m\", \"I am\", sentence)\n sentence = re.sub(r\" m \", \" am \", sentence)\n sentence = re.sub(r\"(\\'re| r )\", \" are \", sentence)\n sentence = re.sub(r\"\\'d\", \" would \", sentence)\n sentence = re.sub(r\"\\'ll\", \" will \", sentence)\n sentence = re.sub(r\"(\\d+)(k)\", r\"\\g<1>000\", sentence)\n # Make word separations\n sentence = re.sub(r\"(\\+|-|\\*|\\/|\\^|\\.)\", \" $1 \", sentence)\n # Remove irrelevant stuff, nonprintable characters and spaces\n sentence = re.sub(r\"(\\'s|\\'S|\\'|\\\"|,|[^ -~]+)\", \"\", sentence)\n sentence = tc.strip_all(sentence)[0]\n\n if sentence == \"\":\n return \"\"\n\n return tc.token_it(tc.lemming(sentence))[0]\n```\n\n\n```python\nfor idx in range(len(S1_train_words)):\n S1_train[idx] = data_tokenizer(S1_train_words[idx])\n\nfor idx in range(len(S2_train_words)):\n S2_train[idx] = data_tokenizer(S2_train_words[idx])\n \nfor idx in range(len(S1_test_words)): \n S1_test[idx] = data_tokenizer(S1_test_words[idx])\n\nfor idx in range(len(S2_test_words)): \n S2_test[idx] = data_tokenizer(S2_test_words[idx])\n```\n\n\"]))\n\n v1, v2 = model((S1, S2))\n d = np.dot(v1[0], v2[0].T)\n res = d > threshold\n \n if verbose == True:\n print(\"S1 = \", S1, \"\\nS2 = \", S2)\n print(\"d = \", d)\n print(\"res = \", res)\n\n return res\n```\n\nNow we can test the model's ability to make predictions.\n\n\n```python\nsentence1 = \"I love running in the park.\"\nsentence2 = \"I like running in park?\"\n# 1 means it is duplicated, 0 otherwise\npredict(sentence1 , sentence2, 0.7, model, verbose=True)\n```\n\nThe Siamese network is capable of catching complicated structures. Concretely, it can identify sentence duplicates although the sentences do not have many words in common.\n", "meta": {"hexsha": "c283ec10ff02fbfcf946deeaa4159a71fa13fff9", "size": 50692, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "src/math_bot/model/GloVeSiameseLSTM2.ipynb", "max_stars_repo_name": "AlinGeorgescu/Math-Bot", "max_stars_repo_head_hexsha": "bf9d2a9c373bd85574a11c11e33526c46723df01", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2021-06-01T16:10:18.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-06T00:37:14.000Z", "max_issues_repo_path": "src/math_bot/model/GloVeSiameseLSTM2.ipynb", "max_issues_repo_name": "AlinGeorgescu/Math-Bot", "max_issues_repo_head_hexsha": "bf9d2a9c373bd85574a11c11e33526c46723df01", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/math_bot/model/GloVeSiameseLSTM2.ipynb", "max_forks_repo_name": "AlinGeorgescu/Math-Bot", "max_forks_repo_head_hexsha": "bf9d2a9c373bd85574a11c11e33526c46723df01", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.8835562549, "max_line_length": 3904, "alphanum_fraction": 0.5844314685, "converted": true, "num_tokens": 9154, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.411110869232168, "lm_q2_score": 0.28140561345566495, "lm_q1q2_score": 0.11568890635456988}}
{"text": "| Name
| Date
|\n| ---------------------------------------------------| ------------------------------------- |\n| Diaaeldin SHALABY
| 07.052021 |\n\nHands-on AI II \nUnit 2 — The Vanishing Gradient Problem (Assignment) \n\nAuthors: S. Lehner, J. Brandstetter, B. SchäflDate: 16-04-2021\n\nThis file is part of the \"Hands-on AI II\" lecture material. The following copyright statement applies to all code within this file.\n\nCopyright statement: Table of contents \n\n Definition of Auxiliaries \n Loading and visualizing Downprojecting and interpreting Loading and preparing \n Training of a Neural Network \n Constructing an FNN Forward pass Backward pass \n Analyzing Gradients \n Collecting and visualizing \n Countermeasure and re-train Comparing gradients \n Deriving Derivatives \n Case hardsigmoid \n Case leaky_relu \n \n\nHow to use this notebook \nThis notebook is designed to run from start to finish. There are different tasks (displayed in orange boxes ) which require your contribution (in form of code, plain text, ...). Most/All of the supplied functions are imported from the file u2_utils.py which can be seen and treated as a black box. However, for further understanding, you can look at the implementations of the helper functions. In order to run this notebook, the packages which are imported at the beginning of u2_utils.py need to be installed.\n\n\n```python\n# Import pre-defined utilities specific to this notebook.\nimport u2_utils as u2\n\n# Import additional utilities needed in this notebook.\nimport math\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport torch\n\nfrom typing import Dict, Sequence\n\n# Setup Jupyter notebook (warning: this may affect all Jupyter notebooks running on the same Jupyter server).\nu2.setup_jupyter()\n```\n\n\n\n\n\n\nSetting up notebook ... finished.
\n\n\n\n\nModule versions \nAs mentioned in the introductiory slides, specific minimum versions of Python itself as well as of used modules is recommended.\n\n\n```python\nu2.check_module_versions()\n```\n\n Installed Python version: 3.8 (✓)\n Installed numpy version: 1.19.1 (✓)\n Installed pandas version: 1.1.3 (✓)\n Installed PyTorch version: 1.7.1 (✓)\n Installed scikit-learn version: 0.23.2 (✓)\n Installed scipy version: 1.5.0 (✓)\n Installed matplotlib version: 3.3.1 (✓)\n Installed seaborn version: 0.11.0 (✓)\n Installed PIL version: 8.0.0 (✓)\n\n\nDefinition of Auxiliaries \nIn this exercise you will be working with a data set composed of images of various handwritten digits. It is probably the most prominent data set in the domain of machine learning: the MNIST data set. The data set distinguishes ten different classes, one for each digit (zero to nine ). For curious minds, more information regarding this data set can be found at:\n\n
\n LeCun, Y., 1998. The MNIST database of handwritten digits. http://yann.lecun.com/exdb/mnist/ . \n \n \nBefore analyzing and tackling the vanishing gradient problem, the data sets needs to be inspected.\n\n\n Execute the notebook until here and try to solve the following tasks:\n
\n Load the MNIST data set using the appropriate function as supplied by us. \n Divide the data set between the training set and the test set in a ratio of $7:1$. \n Visualize the MNIST training set in tabular form. What is the size of both subsets with respect to sample and feature counts? \n \n
\n\n
\n \n \n PX_0 \n PX_1 \n PX_2 \n PX_3 \n PX_4 \n PX_5 \n PX_6 \n PX_7 \n PX_8 \n PX_9 \n ... \n PX_775 \n PX_776 \n PX_777 \n PX_778 \n PX_779 \n PX_780 \n PX_781 \n PX_782 \n PX_783 \n digit \n \n \n \n \n 0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 5 \n \n \n 1 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0 \n \n \n 2 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 4 \n \n \n 3 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 1 \n \n \n 4 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 9 \n \n \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n \n \n 69995 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 2 \n \n \n 69996 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 3 \n \n \n 69997 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 4 \n \n \n 69998 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 5 \n \n \n 69999 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 6 \n \n \n
\n
70000 rows × 785 columns
\n
\n Execute the notebook until here and try to solve the following tasks:\n
\n Reduce the dimensionality of the MNIST training set using PCA and visualize the downprojection. \n Comment on the separability of the MNIST training set with respect to the downprojection. \n \n
\n Execute the notebook until here and try to solve the following tasks:\n
\n Create a corresponding TensorDataset for the training as well as the test set. \n Wrap the previously defined TensorDataset instances in separate DataLoader instances with a batch size of $64$ (shuffle the training data set). \n Scale the features of the training as well as test set by a factor of $1\\,/\\,255$. \n \n
\n The following code snippet is taken from the accompanying exercise notebook. You do not need to modify it for this assignment.\n
\n\n\n```python\ndef train_and_evaluate(model: torch.nn.Module, optimizer: torch.optim.Optimizer,\n device: torch.device, num_epochs: int,\n loader_train: torch.utils.data.DataLoader,\n loader_test: torch.utils.data.DataLoader) -> None:\n \"\"\"\n Auxiliary function for training and evaluating a corresponding model.\n \n :param model: model instance to train and evaluate\n :param optimizer: optimizer to use for model training\n :param device: device to use for model training and evaluation\n :param num_epochs: amount of epochs for model training\n :param loader_train: data loader supplying the training samples\n :param loader_test: data loader supplying the test samples\n :return: None\n \"\"\"\n for epoch in range(num_epochs):\n\n # Train model instance for one epoch.\n u2.train_network(\n model=model, data_loader=loader_train, device=device, optimizer=optimizer)\n\n # Evaluate current model instance.\n performance = u2.test_network(\n model=model, data_loader=loader_train, device=device)\n\n # Print result of current epoch to standard out.\n print(f'Epoch: {str(epoch + 1).zfill(len(str(num_epochs)))} ' +\n f'/ Loss: {performance[0]:.4f} / Accuracy: {performance[1]:.4f}')\n\n # Evaluate final model on test data set.\n performance = u2.test_network(model=model, data_loader=loader_test, device=device)\n print(f'\\nFinal loss: {performance[0]:.4f} / Final accuracy: {performance[1]:.4f}')\n```\n\nTraining of a Neural Network \nLoading and inspecting a new data set is always an exciting moment, but even more exciting is the implementation of a corresponding neural network and applying it to said data set. Hence, in this section you will have to implement and train an appropriate neural network model and revisit your knowledge about the forward as well as the backward pass.
\n\n\n Execute the notebook until here and try to solve the following tasks:\n
\n Implement a class FNN_0 with the following architecture: \n \n
\n Position \n Element \n Comment \n \n 0 \n input \n - \n \n \n 1 \n fully connected \n square weight matrix \n \n \n 2 \n sigmoid \n - \n \n \n 2 \n fully connected \n square weight matrix \n \n \n 3 \n sigmoid \n - \n \n \n 4 \n fully connected \n square weight matrix \n \n \n 5 \n sigmoid \n - \n \n \n 6 \n fully connected \n square weight matrix \n \n \n 7 \n sigmoid \n - \n \n \n 8 \n fully connected \n square weight matrix \n \n \n 9 \n sigmoid \n - \n \n \n 10 \n fully connected \n $10$ output features \n \n \n 11 \n output \n - \n \n
\n
\n Create an instance of FNN_0 as well as of a corresponding Adam optimizer with a learning rate of $0.0001$. \n Print the resulting model and verify the architecture by inspecting the output. \n Train an FNN_0 network for $5$ epochs, print the training accuracy as well as the loss per epoch and report the final test set loss and accuracy. \n \n
\n Execute the notebook until here and try to solve the following tasks:\n
\n Write down a formula for the corresponding forward pass of FNN_0 . Use the same notation as presented during the exercise. \n \n
\n \\begin{equation}\n \\hat{y} = f\\left(h_6(h_5(h_4(h_3(h_2(h_1(\\mathbf{x};\\mathbf{W}_1);\\mathbf{W}_2);\\mathbf{W}_3);\\mathbf{W}_4);\\mathbf{W}_5);\\mathbf{W}_6 \\right )\n \\end{equation}\n \n\n\n\n Execute the notebook until here and try to solve the following tasks:\n
\n Write down a formula for the corresponding backward pass of FNN_0 . Use the same notation as presented during the exercise. \n \n
\n \\begin{align*}\n \\mathbf{W}_6 & \\leftarrow \\mathbf{W}_6 - \\eta \\frac{\\partial L}{\\partial \\mathbf{W}_5} \\\\\n \\mathbf{W}_5 & \\leftarrow \\mathbf{W}_5 - \\eta \\frac{\\partial L}{\\partial h_5}\\frac{\\partial h_5}{\\partial \\mathbf{W}_5} \\\\\n \\mathbf{W}_4 & \\leftarrow \\mathbf{W}_4 - \\eta \\frac{\\partial L}{\\partial h_5}\\frac{\\partial h_5}{\\partial h_4}\\frac{\\partial h_4}{\\partial \\mathbf{W}_4} \\\\\n \\mathbf{W}_3 & \\leftarrow \\mathbf{W}_3 - \\eta \\frac{\\partial L}{\\partial h_5}\\frac{\\partial h_5}{\\partial h_4}\\frac{\\partial h_4}{\\partial h_3}\\frac{\\partial h_3}{\\partial \\mathbf{W}_3} \\\\\n \\mathbf{W}_2 & \\leftarrow \\mathbf{W}_2 - \\eta \\frac{\\partial L}{\\partial h_5}\\frac{\\partial h_5}{\\partial h_4}\\frac{\\partial h_4}{\\partial h_3}\\frac{\\partial h_3}{\\partial h_2}\\frac{\\partial h_2}{\\partial \\mathbf{W}_2} \\\\\n \\mathbf{W}_1 & \\leftarrow \\mathbf{W}_1 - \\eta \\frac{\\partial L}{\\partial h_5}\\frac{\\partial h_5}{\\partial h_4}\\frac{\\partial h_4}{\\partial h_3}\\frac{\\partial h_3}{\\partial h_2}\\frac{\\partial h_2}{\\partial h_1}\\frac{\\partial h_1}{\\partial \\mathbf{W}_1} \\\\\n \\end{align*}\n \n\nAnalyzing Gradients \nActually, the results of FNN_0 do not look that bad. Is there really a problem with a vanishing gradient? This is exactly the point you're going to figure out in this exercise. As a first step, the gradients of a freshly initialized model needs to be collected and analyzed. Afterwards, in case of a vanishing gradient problem, countermeasures need to get deployed.
\n\n\n The following code snippet is taken from the accompanying exercise notebook. You do not need to modify it for this assignment.\n
\n\n\n```python\ndef collect_gradients(model: torch.nn.Module, device: torch.device,\n loader: torch.utils.data.DataLoader) -> Sequence[Dict[str, np.array]]:\n \"\"\"\n Auxiliary function for collecting gradients of a corresponding model.\n \n :param model: model instance to be used for collecting gradients\n :param device: device to use for gradient collection\n :param loader: data loader supplying the samples used for collecting gradients\n :return: sequence of parameter names and gradients, averaged over all parameter elements\n \"\"\"\n model_state = model.training\n model.train()\n model.zero_grad()\n \n # Iterating over the data set and computing the corresponding gradients.\n gradients = {}\n criterion = torch.nn.CrossEntropyLoss()\n for batch_index, (data, target) in enumerate(loader):\n data, target = data.float().to(device), target.long().to(device)\n optimizer.zero_grad()\n output = model(data)\n loss = criterion(output, target)\n loss.backward()\n \n # Collecting the gradients from the current model.\n for name, parameter in model.named_parameters():\n if parameter.grad is not None:\n gradients.setdefault(name, []).append(parameter.grad.view(-1).abs().mean().item())\n model.zero_grad()\n \n # Reset model state and return collected gradients.\n model.train(mode=model_state)\n return gradients\n```\n\n\n Execute the notebook until here and try to solve the following tasks:\n
\n Create a fresh instance of FNN_0 and collect its gradients using the MNIST training set. \n Visualize the gradients of each weight parameter accordingly. \n Do the gradients vanish? \n \n
\n Execute the notebook until here and try to solve the following tasks:\n
\n Assume a vanishing gradient. Apply the countermeasure presented during the accompanying exercise by implementing a corresponding FNN_1 . \n Create an instance of FNN_1 as well as of a corresponding Adam optimizer with a learning rate of $0.0001$. \n Print the resulting model and verify the architecture by inspecting the output. \n Train an FNN_1 network for $5$ epochs, print the training accuracy as well as the loss per epoch and report the final test set loss and accuracy. \n \n
\n Execute the notebook until here and try to solve the following tasks:\n
\n Create a fresh instance of FNN_1 and collect its gradients using the MNIST training set. \n Visualize the gradients of each weight parameter accordingly (include the gradient visualization of FNN_0 ). \n Do the gradients vanish? \n \n
Deriving Derivatives \nIt is already known from the lecture as well as the exercise that activation functions are the primary culprit of the Vanishing Gradient Problem . Hence, it is important to know how the chosen activation functions activate the input and consequently what the derivative is.
\n\n\n Execute the notebook until here and try to solve the following tasks (hint: have a look at the official
PyTorch documentation ):\n
\n Implement the hardsigmoid activation function as it was done for relu in the exercise. \n Implement the derivative of the hardsigmoid activation function accordingly. \n Find $3$ different inputs showing the value range of the hardsigmoid activation function. \n Plot the hardsigmoid activation function indluding its derivative for the input range $[-6; 6]$. \n \n
\n Execute the notebook until here and try to solve the following tasks (hint: have a look at the official
PyTorch documentation ):\n
\n Implement the leaky_relu activation function as it was done for relu in the exercise. Use a negative slope of $0.37$. \n Implement the derivative of the leaky_relu activation function accordingly. \n Find $3$ different inputs showing the value range of the leaky_relu activation function. \n Plot the leaky_relu activation function indluding its derivative for the input range $[-6; 6]$. \n \n
\n\nBoth Alice and Bob used the Hadamard basis.\n \n\n\nThey both used the standard basis.\n \n\n\nAlice transformed to the Hadamard basis, and Bob measured in the standard basis.\n \n\n\nAlice used the standard basis, and Bob the Hadamard basis.\n \n \n\nWhen Alice and Bob agree on the same basis, they keep the transferred bit. When they disagree, they discard it. Thus, it is possible for Alice and Bob to securely communicate an $n$ bit private key using $2n$ qubits.\n\n\n#### Example \n\nFor example, let us consider the case where Alice wants to send the bit $0$. She prepares her qubit in the $\\lvert 0 \\rangle$ state and then randomly selects whether or not she applies the Hadamard gate to it. Let's say she does apply the Hadamard gate to her qubit, obtaining the $\\lvert + \\rangle$ state. \n\nThen, consider, the cased where Bob measures the qubit in the standard basis. After Bob's measurement, Alice and Bob communicate through the classical channel. Alice tells Bob that she applied the Hadamard gate to her qubit and Bob tells Alice that he measured it in the standard basis. So, they abandon the first bit.\n\n\n$$\\text{2. Example of one application of the BB84 protocol. In this case, Alice and Bob will discard this bit.}$$\n\n\nNext, Alice picks a second bit, $1$, encodes it into a qubit and selects at random whether to apply or not the Hadamard gate. Let us now assume that she does not apply the Hadamard gate. Thus, the qubit is in the state $\\lvert 1\\rangle $. Alice then sends her qubit to Bob. Bob selects at random one of his two measurement bases. Let us consider in this\ncase that he measures in the standard basis. As the qubit is in the state $\\lvert 1\\rangle $ the outcome of the measurement will be $1$. Thus, Bob chooses value $1$ for his second classical bit, the same as Alice did. Finally, Alice tells Bob that she did not apply the Hadamard gate, and Bob tells Alice that he measured in the standard basis. So, both Alice and Bob will use the bit with the value $1$ as the first bit in their secret key.\n\n\n\n$$\\text{3. Example of another application of the BB84 protocol.} \\\\ \\text{In this case, Alice and Bob successfully communicate the value of a bit.}$$\n\n\n### QISKit: BB84 protocol \n\n#### 1) Show the communication of one bit \n\n\n```python\nfrom initialize import *\nimport random\n\n#initialize quantum program\nmy_alg = initialize(circuit_name = 'bb84', qubit_number=1, bit_number=1, backend = 'local_qasm_simulator', shots = 1)\n\n#add gates to the circuit\n\n# Alice encodes the bit 1 into a qubit\nmy_alg.q_circuit.x(my_alg.q_reg[0])\n\n# Alice randomly applies the Hadamard gate to go to the Hadamard basis\na = random.randint(0,1)\nif a==1:\n my_alg.q_circuit.h(my_alg.q_reg[0])\n \n# Bob randomly applies the Hadamard gate to go to the Hadamard basis\nb = random.randint(0,1)\nif b==1:\n my_alg.q_circuit.h(my_alg.q_reg[0])\n\nmy_alg.q_circuit.measure(my_alg.q_reg[0], my_alg.c_reg[0]) # measures first qubit\n\n# print list of gates in the circuit\nprint('List of gates:')\nfor circuit in my_alg.q_circuit:\n print(circuit.name)\n\n#Execute the quantum algorithm\nresult = my_alg.Q_program.execute(my_alg.circ_name, backend=my_alg.backend, shots= my_alg.shots)\n\n#Show the results obtained from the quantum algorithm \ncounts = result.get_counts(my_alg.circ_name)\n\nprint('\\nThe measured outcomes of the circuits are:',counts)\n\nif a == b:\n print('Alice and Bob agree on the basis, thus they keep the bit')\nelse: \n print(\"Alice and Bob don't agree the same basis, thus they discard the bit\")\n \n```\n\n List of gates:\n x\n h\n measure\n \n The measured outcomes of the circuits are: {'0': 1}\n Alice and Bob don't agree the same basis, thus they discard the bit\n\n\n /anaconda/lib/python3.6/site-packages/qiskit/backends/local/qasm_simulator_cpp.py:89: DeprecationWarning: The behavior of getting statevector from simulators by setting shots=1 is deprecated and will be removed. Use the local_statevector_simulator instead, or place explicit snapshot instructions.\n DeprecationWarning)\n\n\n## Problems\n\n\n\n\n\nAlice wants to send Bob the following private key\n\n\\begin{equation}\n101011\n\\end{equation}\n\nShe encodes those bits into the correspondig states of qubits and performs the gates H-H-I-I-I-H on each qubit. Bob measures the qubits in the following bases: Z-H-H-Z-H-H\n\n\n \nFind the possible outcomes of Bob's measurements\n \n\n\nFind the bits of the private key accepted by Alice and Bob\n \n \n\n \n\n\nImagine that a third party, Eve, intercepts Alice's qubits. She measures the intercepted qubit by randomly selecting either the Hadamard or the standard basis and then forwards the qubits to Bob.\n\n\n \nIs it possible for Eve to find out the bit that Alice is sending to Bob without being discovered?\n \n\n\nWhat is the probability that Eve successfully finds out the value of a bit? \n \n\n \n\n\nWrite a QISKit program for the transmission of a 1024 bits provate key between Alice and Bob\n \n\n \n\n## References\n\n[1] D. Dieks, Physics Letters A, 92, 271 (1982).\n\n[2] W. K. Wootters and W. H. Zurek, Nature, 299.802 (1982).\n\n[3] C. H. Bennett and G. Brassard, In Proceedings of IEEE International Conference on Computers, Systems and Signal Processing, volume 175, page 8. New York, 1984.\n", "meta": {"hexsha": "9b640f7b1395d2af36c4b2d56385aa15a368f0b8", "size": 14980, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "9.Quantum criptography.ipynb", "max_stars_repo_name": "miamico/IBM-Teach-Me-Quantum", "max_stars_repo_head_hexsha": "2229f7cccb656aa89ea12be14d8e78ea80115936", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "9.Quantum criptography.ipynb", "max_issues_repo_name": "miamico/IBM-Teach-Me-Quantum", "max_issues_repo_head_hexsha": "2229f7cccb656aa89ea12be14d8e78ea80115936", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "9.Quantum criptography.ipynb", "max_forks_repo_name": "miamico/IBM-Teach-Me-Quantum", "max_forks_repo_head_hexsha": "2229f7cccb656aa89ea12be14d8e78ea80115936", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.9226361032, "max_line_length": 917, "alphanum_fraction": 0.6036715621, "converted": true, "num_tokens": 2844, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.388618026705849, "lm_q2_score": 0.29746995506106744, "lm_q1q2_score": 0.11560218694010961}}
{"text": "\n\n\n\n\n```python\nimport cirq\nimport sympy\nimport numpy as np\nimport tensorflow as tf\nimport tensorflow_quantum as tfq\n\n# visualization tools\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom cirq.contrib.svg import SVGCircuit\nnp.random.seed(1234)\n```\n\n## 1. Data preparation\n\nYou will begin by preparing the fashion-MNIST dataset for running on a quantum computer.\n\n### 1.1 Download fashion-MNIST\n\nThe first step is to get the traditional fashion-mnist dataset. This can be done using the `tf.keras.datasets` module.\n\n\n```python\n(x_train, y_train), (x_test, y_test) = tf.keras.datasets.fashion_mnist.load_data()\n\n# Rescale the images from [0,255] to the [0.0,1.0] range.\nx_train, x_test = x_train/255.0, x_test/255.0\n\nprint(\"Number of original training examples:\", len(x_train))\nprint(\"Number of original test examples:\", len(x_test))\n```\n\n Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz\n 32768/29515 [=================================] - 0s 0us/step\n 40960/29515 [=========================================] - 0s 0us/step\n Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz\n 26427392/26421880 [==============================] - 0s 0us/step\n 26435584/26421880 [==============================] - 0s 0us/step\n Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz\n 16384/5148 [===============================================================================================] - 0s 0us/step\n Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz\n 4423680/4422102 [==============================] - 0s 0us/step\n 4431872/4422102 [==============================] - 0s 0us/step\n Number of original training examples: 60000\n Number of original test examples: 10000\n\n\nFilter the dataset to keep just the T-shirts/tops and dresses, remove the other classes. At the same time convert the label, `y`, to boolean: True for 0 and False for 3.\n\n\n```python\ndef filter_03(x, y):\n keep = (y == 0) | (y == 3)\n x, y = x[keep], y[keep]\n y = y == 0\n return x,y\n```\n\n\n```python\nx_train, y_train = filter_03(x_train, y_train)\nx_test, y_test = filter_03(x_test, y_test)\n\nprint(\"Number of filtered training examples:\", len(x_train))\nprint(\"Number of filtered test examples:\", len(x_test))\n```\n\n Number of filtered training examples: 12000\n Number of filtered test examples: 2000\n\n\n\n```python\nprint(y_train[0])\n\nplt.imshow(x_train[0, :, :])\nplt.colorbar()\n```\n\n### 1.2 Downscale the images\n\nJust like the MNIST example, you will need to downscale these images in order to be within the boundaries for current quantum computers. This time however you will use a PCA transformation to reduce the dimensions instead of a `tf.image.resize` operation.\n\n\n```python\ndef truncate_x(x_train, x_test, n_components=10):\n \"\"\"Perform PCA on image dataset keeping the top `n_components` components.\"\"\"\n n_points_train = tf.gather(tf.shape(x_train), 0)\n n_points_test = tf.gather(tf.shape(x_test), 0)\n\n # Flatten to 1D\n x_train = tf.reshape(x_train, [n_points_train, -1])\n x_test = tf.reshape(x_test, [n_points_test, -1])\n\n # Normalize.\n feature_mean = tf.reduce_mean(x_train, axis=0)\n x_train_normalized = x_train - feature_mean\n x_test_normalized = x_test - feature_mean\n\n # Truncate.\n e_values, e_vectors = tf.linalg.eigh(\n tf.einsum('ji,jk->ik', x_train_normalized, x_train_normalized))\n return tf.einsum('ij,jk->ik', x_train_normalized, e_vectors[:,-n_components:]), \\\n tf.einsum('ij,jk->ik', x_test_normalized, e_vectors[:, -n_components:])\n```\n\n\n```python\nDATASET_DIM = 10\nx_train, x_test = truncate_x(x_train, x_test, n_components=DATASET_DIM)\nprint(f'New datapoint dimension:', len(x_train[0]))\n```\n\n New datapoint dimension: 10\n\n\nThe last step is to reduce the size of the dataset to just 1000 training datapoints and 200 testing datapoints.\n\n\n```python\nN_TRAIN = 1000\nN_TEST = 200\nx_train, x_test = x_train[:N_TRAIN], x_test[:N_TEST]\ny_train, y_test = y_train[:N_TRAIN], y_test[:N_TEST]\n```\n\n\n```python\nprint(\"New number of training examples:\", len(x_train))\nprint(\"New number of test examples:\", len(x_test))\n```\n\n New number of training examples: 1000\n New number of test examples: 200\n\n\n## 2. Relabeling and computing PQK features\n\nYou will now prepare a \"stilted\" quantum dataset by incorporating quantum components and re-labeling the truncated fashion-MNIST dataset you've created above. In order to get the most seperation between quantum and classical methods, you will first prepare the PQK features and then relabel outputs based on their values. \n\n### 2.1 Quantum encoding and PQK features\nYou will create a new set of features, based on `x_train`, `y_train`, `x_test` and `y_test` that is defined to be the 1-RDM on all qubits of: \n\n$V(x_{\\text{train}} / n_{\\text{trotter}}) ^ {n_{\\text{trotter}}} U_{\\text{1qb}} | 0 \\rangle$\n\nWhere $U_\\text{1qb}$ is a wall of single qubit rotations and $V(\\hat{\\theta}) = e^{-i\\sum_i \\hat{\\theta_i} (X_i X_{i+1} + Y_i Y_{i+1} + Z_i Z_{i+1})}$\n\nFirst, you can generate the wall of single qubit rotations:\n\n\n```python\ndef single_qubit_wall(qubits, rotations):\n \"\"\"Prepare a single qubit X,Y,Z rotation wall on `qubits`.\"\"\"\n wall_circuit = cirq.Circuit()\n for i, qubit in enumerate(qubits):\n for j, gate in enumerate([cirq.X, cirq.Y, cirq.Z]):\n wall_circuit.append(gate(qubit) ** rotations[i][j])\n\n return wall_circuit\n```\n\nYou can quickly verify this works by looking at the circuit:\n\n\n```python\nSVGCircuit(single_qubit_wall(\n cirq.GridQubit.rect(1,4), np.random.uniform(size=(4, 3))))\n```\n\n findfont: Font family ['Arial'] not found. Falling back to DejaVu Sans.\n\n\n\n\n\n \n\n \n\n\n\nNext you can prepare $V(\\hat{\\theta})$ with the help of `tfq.util.exponential` which can exponentiate any commuting `cirq.PauliSum` objects:\n\n\n```python\ndef v_theta(qubits):\n \"\"\"Prepares a circuit that generates V(\\theta).\"\"\"\n ref_paulis = [\n cirq.X(q0) * cirq.X(q1) + \\\n cirq.Y(q0) * cirq.Y(q1) + \\\n cirq.Z(q0) * cirq.Z(q1) for q0, q1 in zip(qubits, qubits[1:])\n ]\n exp_symbols = list(sympy.symbols('ref_0:'+str(len(ref_paulis))))\n return tfq.util.exponential(ref_paulis, exp_symbols), exp_symbols\n```\n\nThis circuit might be a little bit harder to verify by looking at, but you can still examine a two qubit case to see what is happening:\n\n\n```python\ntest_circuit, test_symbols = v_theta(cirq.GridQubit.rect(1, 2))\nprint(f'Symbols found in circuit:{test_symbols}')\nSVGCircuit(test_circuit)\n```\n\n Symbols found in circuit:[ref_0]\n\n\n\n\n\n \n\n \n\n\n\nNow you have all the building blocks you need to put your full encoding circuits together:\n\n\n```python\ndef prepare_pqk_circuits(qubits, classical_source, n_trotter=10):\n \"\"\"Prepare the pqk feature circuits around a dataset.\"\"\"\n n_qubits = len(qubits)\n n_points = len(classical_source)\n\n # Prepare random single qubit rotation wall.\n random_rots = np.random.uniform(-2, 2, size=(n_qubits, 3))\n initial_U = single_qubit_wall(qubits, random_rots)\n\n # Prepare parametrized V\n V_circuit, symbols = v_theta(qubits)\n exp_circuit = cirq.Circuit(V_circuit for t in range(n_trotter))\n \n # Convert to `tf.Tensor`\n initial_U_tensor = tfq.convert_to_tensor([initial_U])\n initial_U_splat = tf.tile(initial_U_tensor, [n_points])\n\n full_circuits = tfq.layers.AddCircuit()(\n initial_U_splat, append=exp_circuit)\n # Replace placeholders in circuits with values from `classical_source`.\n return tfq.resolve_parameters(\n full_circuits, tf.convert_to_tensor([str(x) for x in symbols]),\n tf.convert_to_tensor(classical_source*(n_qubits/3)/n_trotter))\n```\n\nChoose some qubits and prepare the data encoding circuits:\n\n\n```python\nqubits = cirq.GridQubit.rect(1, DATASET_DIM + 1)\nq_x_train_circuits = prepare_pqk_circuits(qubits, x_train)\nq_x_test_circuits = prepare_pqk_circuits(qubits, x_test)\n```\n\nNext, compute the PQK features based on the 1-RDM of the dataset circuits above and store the results in `rdm`, a `tf.Tensor` with shape `[n_points, n_qubits, 3]`. The entries in `rdm[i][j][k]` = $\\langle \\psi_i | OP^k_j | \\psi_i \\rangle$ where `i` indexes over datapoints, `j` indexes over qubits and `k` indexes over $\\lbrace \\hat{X}, \\hat{Y}, \\hat{Z} \\rbrace$ .\n\n\n```python\ndef get_pqk_features(qubits, data_batch):\n \"\"\"Get PQK features based on above construction.\"\"\"\n ops = [[cirq.X(q), cirq.Y(q), cirq.Z(q)] for q in qubits]\n ops_tensor = tf.expand_dims(tf.reshape(tfq.convert_to_tensor(ops), -1), 0)\n batch_dim = tf.gather(tf.shape(data_batch), 0)\n ops_splat = tf.tile(ops_tensor, [batch_dim, 1])\n exp_vals = tfq.layers.Expectation()(data_batch, operators=ops_splat)\n rdm = tf.reshape(exp_vals, [batch_dim, len(qubits), -1])\n return rdm\n```\n\n\n```python\nx_train_pqk = get_pqk_features(qubits, q_x_train_circuits)\nx_test_pqk = get_pqk_features(qubits, q_x_test_circuits)\nprint('New PQK training dataset has shape:', x_train_pqk.shape)\nprint('New PQK testing dataset has shape:', x_test_pqk.shape)\n```\n\n New PQK training dataset has shape: (1000, 11, 3)\n New PQK testing dataset has shape: (200, 11, 3)\n\n\n### 2.2 Re-labeling based on PQK features\nNow that you have these quantum generated features in `x_train_pqk` and `x_test_pqk`, it is time to re-label the dataset. To achieve maximum seperation between quantum and classical performance you can re-label the dataset based on the spectrum information found in `x_train_pqk` and `x_test_pqk`.\n\nNote: This preparation of your dataset to explicitly maximize the seperation in performance between the classical and quantum models might feel like cheating, but it provides a **very** important proof of existance for datasets that are hard for classical computers and easy for quantum computers to model. There would be no point in searching for quantum advantage in QML if you couldn't first create something like this to demonstrate advantage.\n\n\n```python\ndef compute_kernel_matrix(vecs, gamma):\n \"\"\"Computes d[i][j] = e^ -gamma * (vecs[i] - vecs[j]) ** 2 \"\"\"\n scaled_gamma = gamma / (\n tf.cast(tf.gather(tf.shape(vecs), 1), tf.float32) * tf.math.reduce_std(vecs))\n return scaled_gamma * tf.einsum('ijk->ij',(vecs[:,None,:] - vecs) ** 2)\n\ndef get_spectrum(datapoints, gamma=1.0):\n \"\"\"Compute the eigenvalues and eigenvectors of the kernel of datapoints.\"\"\"\n KC_qs = compute_kernel_matrix(datapoints, gamma)\n S, V = tf.linalg.eigh(KC_qs)\n S = tf.math.abs(S)\n return S, V\n```\n\n\n```python\nS_pqk, V_pqk = get_spectrum(\n tf.reshape(tf.concat([x_train_pqk, x_test_pqk], 0), [-1, len(qubits) * 3]))\n\nS_original, V_original = get_spectrum(\n tf.cast(tf.concat([x_train, x_test], 0), tf.float32), gamma=0.005)\n\nprint('Eigenvectors of pqk kernel matrix:', V_pqk)\nprint('Eigenvectors of original kernel matrix:', V_original)\n```\n\n Eigenvectors of pqk kernel matrix: tf.Tensor(\n [[ 0.02095697 0.01059745 0.02166322 ... 0.09526508 0.00300356\n 0.02826785]\n [ 0.02293038 0.04663572 0.00791177 ... 0.00220983 -0.6957587\n 0.02859015]\n [ 0.01778554 -0.0030075 -0.02552235 ... 0.02335721 0.00414519\n 0.02690097]\n ...\n [-0.0605794 0.01324826 0.02695336 ... 0.00716051 0.03977184\n 0.03853431]\n [-0.06333087 -0.00304116 0.00977427 ... -0.03250755 0.02224028\n 0.03674842]\n [-0.05860277 0.00584422 0.00264832 ... -0.04459745 -0.01932838\n 0.03299437]], shape=(1200, 1200), dtype=float32)\n Eigenvectors of original kernel matrix: tf.Tensor(\n [[ 3.8356818e-02 2.8347293e-02 -1.1697864e-02 ... -4.0755421e-02\n 2.0624822e-02 3.2069720e-02]\n [-4.0181600e-02 8.8809701e-03 -1.3882567e-02 ... -7.6112538e-03\n 7.1638334e-01 2.8819481e-02]\n [-1.6671857e-02 1.3503703e-02 -3.6638588e-02 ... 4.2131193e-02\n -3.7604037e-03 2.1954076e-02]\n ...\n [-3.0156480e-02 -1.6716314e-02 -1.6033923e-02 ... 2.1481956e-03\n -5.8309413e-03 2.3656894e-02]\n [ 3.9776899e-03 -4.9988784e-02 -5.2833343e-03 ... -2.2350436e-02\n -4.1845851e-02 2.7820019e-02]\n [-1.6657291e-02 -8.1861708e-03 -4.3234091e-02 ... -3.2867838e-04\n 9.1463570e-03 1.8750878e-02]], shape=(1200, 1200), dtype=float32)\n\n\nNow you have everything you need to re-label the dataset! Now you can consult with the flowchart to better understand how to maximize performance seperation when re-labeling the dataset:\n\n\n\nIn order to maximize the seperation between quantum and classical models, you will attempt to maximize the geometric difference between the original dataset and the PQK features kernel matrices $g(K_1 || K_2) = \\sqrt{ || \\sqrt{K_2} K_1^{-1} \\sqrt{K_2} || _\\infty}$ using `S_pqk, V_pqk` and `S_original, V_original`. A large value of $g$ ensures that you initially move to the right in the flowchart down towards a prediction advantage in the quantum case.\n\nNote: Computing quantities for $s$ and $d$ are also very useful when looking to better understand performance seperations. In this case ensuring a large $g$ value is enough to see performance seperation.\n\n\n```python\ndef get_stilted_dataset(S, V, S_2, V_2, lambdav=1.1):\n \"\"\"Prepare new labels that maximize geometric distance between kernels.\"\"\"\n S_diag = tf.linalg.diag(S ** 0.5)\n S_2_diag = tf.linalg.diag(S_2 / (S_2 + lambdav) ** 2)\n scaling = S_diag @ tf.transpose(V) @ \\\n V_2 @ S_2_diag @ tf.transpose(V_2) @ \\\n V @ S_diag\n\n # Generate new lables using the largest eigenvector.\n _, vecs = tf.linalg.eig(scaling)\n new_labels = tf.math.real(\n tf.einsum('ij,j->i', tf.cast(V @ S_diag, tf.complex64), vecs[-1])).numpy()\n # Create new labels and add some small amount of noise.\n final_y = new_labels > np.median(new_labels)\n noisy_y = (final_y ^ (np.random.uniform(size=final_y.shape) > 0.95))\n return noisy_y\n```\n\n\n```python\ny_relabel = get_stilted_dataset(S_pqk, V_pqk, S_original, V_original)\ny_train_new, y_test_new = y_relabel[:N_TRAIN], y_relabel[N_TRAIN:]\n```\n\n## 3. Comparing models\nNow that you have prepared your dataset it is time to compare model performance. You will create two small feedforward neural networks and compare performance when they are given access to the PQK features found in `x_train_pqk`.\n\n### 3.1 Create PQK enhanced model\nUsing standard `tf.keras` library features you can now create and a train a model on the `x_train_pqk` and `y_train_new` datapoints:\n\n\n```python\n#docs_infra: no_execute\ndef create_pqk_model():\n model = tf.keras.Sequential()\n model.add(tf.keras.layers.Dense(32, activation='sigmoid', input_shape=[len(qubits) * 3,]))\n model.add(tf.keras.layers.Dense(16, activation='sigmoid'))\n model.add(tf.keras.layers.Dense(1))\n return model\n\npqk_model = create_pqk_model()\npqk_model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n optimizer=tf.keras.optimizers.Adam(learning_rate=0.003),\n metrics=['accuracy'])\n\npqk_model.summary()\n```\n\n Model: \"sequential\"\n _________________________________________________________________\n Layer (type) Output Shape Param # \n =================================================================\n dense (Dense) (None, 32) 1088 \n \n dense_1 (Dense) (None, 16) 528 \n \n dense_2 (Dense) (None, 1) 17 \n \n =================================================================\n Total params: 1,633\n Trainable params: 1,633\n Non-trainable params: 0\n _________________________________________________________________\n\n\n\n```python\n#docs_infra: no_execute\npqk_history = pqk_model.fit(tf.reshape(x_train_pqk, [N_TRAIN, -1]),\n y_train_new,\n batch_size=32,\n epochs=1000,\n verbose=0,\n validation_data=(tf.reshape(x_test_pqk, [N_TEST, -1]), y_test_new))\n```\n\n### 3.2 Create a classical model\nSimilar to the code above you can now also create a classical model that doesn't have access to the PQK features in your stilted dataset. This model can be trained using `x_train` and `y_label_new`.\n\n\n```python\n#docs_infra: no_execute\ndef create_fair_classical_model():\n model = tf.keras.Sequential()\n model.add(tf.keras.layers.Dense(32, activation='sigmoid', input_shape=[DATASET_DIM,]))\n model.add(tf.keras.layers.Dense(16, activation='sigmoid'))\n model.add(tf.keras.layers.Dense(1))\n return model\n\nmodel = create_fair_classical_model()\nmodel.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n optimizer=tf.keras.optimizers.Adam(learning_rate=0.03),\n metrics=['accuracy'])\n\nmodel.summary()\n```\n\n Model: \"sequential_1\"\n _________________________________________________________________\n Layer (type) Output Shape Param # \n =================================================================\n dense_3 (Dense) (None, 32) 352 \n \n dense_4 (Dense) (None, 16) 528 \n \n dense_5 (Dense) (None, 1) 17 \n \n =================================================================\n Total params: 897\n Trainable params: 897\n Non-trainable params: 0\n _________________________________________________________________\n\n\n\n```python\n#docs_infra: no_execute\nclassical_history = model.fit(x_train,\n y_train_new,\n batch_size=32,\n epochs=1000,\n verbose=0,\n validation_data=(x_test, y_test_new))\n```\n\n### 3.3 Compare performance\nNow that you have trained the two models you can quickly plot the performance gaps in the validation data between the two. Typically both models will achieve > 0.9 accuaracy on the training data. However on the validation data it becomes clear that only the information found in the PQK features is enough to make the model generalize well to unseen instances.\n\n\n```python\n#docs_infra: no_execute\nplt.figure(figsize=(10,5))\nplt.plot(classical_history.history['accuracy'], label='accuracy_classical')\nplt.plot(classical_history.history['val_accuracy'], label='val_accuracy_classical')\nplt.plot(pqk_history.history['accuracy'], label='accuracy_quantum')\nplt.plot(pqk_history.history['val_accuracy'], label='val_accuracy_quantum')\nplt.xlabel('Epoch')\nplt.ylabel('Accuracy')\nplt.legend()\n```\n\nSuccess: You have engineered a stilted quantum dataset that can intentionally defeat classical models in a fair (but contrived) setting. Try comparing results using other types of classical models. The next step is to try and see if you can find new and interesting datasets that can defeat classical models without needing to engineer them yourself!\n\n## 4. Important conclusions\n\nThere are several important conclusions you can draw from this and the [MNIST](https://www.tensorflow.org/quantum/tutorials/mnist) experiments:\n\n1. It's very unlikely that the quantum models of today will beat classical model performance on classical data. Especially on today's classical datasets that can have upwards of a million datapoints.\n\n2. Just because the data might come from a hard to classically simulate quantum circuit, doesn't necessarily make the data hard to learn for a classical model.\n\n3. Datasets (ultimately quantum in nature) that are easy for quantum models to learn and hard for classical models to learn do exist, regardless of model architecture or training algorithms used.\n", "meta": {"hexsha": "ba5114f57719b79e7396a52e301020cd8e4efa19", "size": 143809, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/quantum_data.ipynb", "max_stars_repo_name": "artiseza/quantum", "max_stars_repo_head_hexsha": "72f6e5bae843c841117426a0c8e1ee1d6557995e", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "docs/tutorials/quantum_data.ipynb", "max_issues_repo_name": "artiseza/quantum", "max_issues_repo_head_hexsha": "72f6e5bae843c841117426a0c8e1ee1d6557995e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/tutorials/quantum_data.ipynb", "max_forks_repo_name": "artiseza/quantum", "max_forks_repo_head_hexsha": "72f6e5bae843c841117426a0c8e1ee1d6557995e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 106.2889874353, "max_line_length": 61545, "alphanum_fraction": 0.7531587036, "converted": true, "num_tokens": 11648, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.23651624720889433, "lm_q1q2_score": 0.11548695622978791}}
{"text": "```python\nimport numpy as np\nimport pandas as pd\nimport linearsolve as ls\nimport matplotlib.pyplot as plt\nplt.style.use('classic')\n%matplotlib inline\n```\n\n# Homework 7\n\n**Instructions:** Complete the notebook below. Download the completed notebook in HTML format. Upload assignment using Canvas.\n\n**Due:** Feb. 23 at **2pm.**\n\n## Exercise: The Labor-Leisure Tradeoff\n\n\\begin{align}\n\\frac{\\varphi}{1-L_t} & = \\frac{(1-\\alpha)A_tK_t^{\\alpha}L_t^{-\\alpha}}{C_t} \\tag{1}\n\\end{align}\n\n**Questions** \n\n1. Explain words why the left-hand side of equation (1) represents the marginal cost to the household of working. A complete answer will make use of the term *marginal utility* .\n2. Explain words why the right-hand side of equation (1) represents the marginal benefit to the household of supplying labor (i.e., working). A complete answer will make use of the terms *marginal utility* and *marginal product*.\n3. Holding everything else constant, according to equation (1), what effect will an increase in TFP have on equilibrium labor? Explain the economic intuition behind your answer.\n4. Holding everything else constant, according to equation (1), what effect will an increase in household consumption have on equilibrium labor? Explain the economic intuition behind your answer.\n\n**Answers**\n\n1. \n\n2. \n\n3. \n\n4. \n\n## Exercise: The Euler Equation\n\n\\begin{align}\n\\frac{1}{C_t} & = \\beta \\left[\\frac{\\alpha A_{t+1}K_{t+1}^{\\alpha-1}L_{t+1}^{1-\\alpha} +1-\\delta }{C_{t+1}}\\right]\\tag{2}\n\\end{align}\n\n**Questions** \n\n1. Explain words why the left-hand side of equation (2) represents the marginal cost to the household of saving (i.e., building new capital). A complete answer will make use of the term *marginal utility* .\n2. Explain words why the right-hand side of equation (2) represents the marginal benefit to the household of saving. A complete answer will make use of the terms *marginal utility* and *marginal product*.\n3. Holding everything else constant, according to equation (2), what effect will an increase in TFP in period $t+1$ have on the household's choice for capital in period $t+1$? Explain the economic intuition behind your answer.\n3. Holding everything else constant, according to equation (2), what effect will an increase in consumption in period $t$ have on the household's choice for capital in period $t+1$? Explain the economic intuition behind your answer.\n3. Holding everything else constant, according to equation (2), what effect will an increase in consumption in period $t+1$ have on the household's choice for capital in period $t+1$? Explain the economic intuition behind your answer.\n\n**Answers**\n\n1. \n\n2. \n\n3. \n\n3. \n\n4. \n", "meta": {"hexsha": "695da548aaa5247ce7c1907179fadfd4d281e21f", "size": 4092, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Homework Notebooks/Econ126_Winter2021_Homework_07_blank.ipynb", "max_stars_repo_name": "letsgoexploring/econ126", "max_stars_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-12-12T16:28:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-24T12:11:04.000Z", "max_issues_repo_path": "Homework Notebooks/Econ126_Winter2021_Homework_07_blank.ipynb", "max_issues_repo_name": "letsgoexploring/econ126", "max_issues_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1, "max_issues_repo_issues_event_min_datetime": "2019-04-29T08:50:41.000Z", "max_issues_repo_issues_event_max_datetime": "2019-04-29T08:51:05.000Z", "max_forks_repo_path": "Homework Notebooks/Econ126_Winter2021_Homework_07_blank.ipynb", "max_forks_repo_name": "letsgoexploring/econ126", "max_forks_repo_head_hexsha": "05f50d2392dd1c7c38b14950cb8d7eff7ff775ee", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-03-08T18:49:19.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T23:27:16.000Z", "avg_line_length": 34.1, "max_line_length": 241, "alphanum_fraction": 0.605083089, "converted": true, "num_tokens": 670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4882833952958347, "lm_q2_score": 0.2365162364457076, "lm_q1q2_score": 0.11548695097430255}}
{"text": "```python\nname = \"Ricardo Hideki Hangai Kojo\" # write YOUR NAME\n\nhonorPledge = \"I affirm that I have not given or received any unauthorized \" \\\n \"help on this assignment, and that this work is my own.\\n\"\n\n\nprint(\"\\nName: \", name)\nprint(\"\\nHonor pledge: \", honorPledge)\n```\n\n \n Name: Ricardo Hideki Hangai Kojo\n \n Honor pledge: I affirm that I have not given or received any unauthorized help on this assignment, and that this work is my own.\n \n\n\n# MAC0460 / MAC5832 (2021)\nSlides of Lecture 03 and Lecture 03 of *Learning from Data*)\n- to understand the core idea (*optimization of a loss or cost function*) for parameter adjustment in machine learning\nExercise 1 \nUsing only **NumPy** (a quick introduction to this library can be found [here](http://cs231n.github.io/python-numpy-tutorial/)), complete the two functions below. Recall that $\\mathbf{X} \\in \\mathbb{R}^{N\\times d}$; thus you will need to add a component of value 1 to each of the observations in $\\mathbf{X}$ before performing the computation described above.\n\nNOTE: Although the dataset above has data of dimension $d=1$, your code must be generic (it should work for $d\\geq1$)\n\n## 1.1. Weight computation function \n\n\n```python\ndef normal_equation_weights(X, y):\n \"\"\"\n Calculates the weights of a linear function using the normal equation method.\n You should add into X a new column with 1s.\n\n :param X: design matrix\n :type X: np.ndarray(shape=(N, d))\n :param y: regression targets\n :type y: np.ndarray(shape=(N, 1))\n :return: weight vector\n :rtype: np.ndarray(shape=(d+1, 1))\n \"\"\"\n \n # START OF YOUR CODE:\n N = X.shape[0]\n X_tilde = np.column_stack((np.ones((N, 1)), X))\n X_cross = np.dot(np.linalg.inv(np.dot(X_tilde.T, X_tilde)), X_tilde.T)\n w = np.dot(X_cross, y)\n \n return w\n # END OF YOUR CODE\n```\n\n\n```python\n# test of function normal_equation_weights()\n\nw = 0 # this is not necessary\nw = normal_equation_weights(X, y)\nprint(\"Estimated w =\\n\", w)\n```\n\n Estimated w =\n [[12043.47818971]\n [ 49.88841379]]\n\n\n## 1.2. Prediction function \n\n\n```python\ndef normal_equation_prediction(X, w):\n \"\"\"\n Calculates the prediction over a set of observations X using the linear function\n characterized by the weight vector w.\n You should add into X a new column with 1s.\n\n :param X: design matrix\n :type X: np.ndarray(shape=(N, d))\n :param w: weight vector\n :type w: np.ndarray(shape=(d+1, 1))\n :param y: regression prediction\n :type y: np.ndarray(shape=(N, 1))\n \"\"\"\n \n # START OF YOUR CODE:\n N = X.shape[0]\n X_tilde = np.column_stack((np.ones((N, 1)), X))\n y = np.dot(X_tilde, w)\n \n return y\n # END OF YOUR CODE\n```\n\n## 1.3. Coefficient of determination \nWe can use the [$R^2$](https://pt.wikipedia.org/wiki/R%C2%B2) metric (Coefficient of determination) to evaluate how well the linear model fits the data.\n\n**Which $𝑅^2$ value would you expect to observe ?**\n\n\n```python\nfrom sklearn.metrics import r2_score\n\n# test of function normal_equation_prediction()\nprediction = normal_equation_prediction(X, w)\n\n# compute the R2 score using the r2_score function from sklearn\n# Replace 0 with an appropriate call of the function\n\n# START OF YOUR CODE:\nr_2 = r2_score(y, prediction)\n# END OF YOUR CODE\n\nplot_points_regression(X,\n y,\n title='Real estate prices prediction',\n xlabel=\"m\\u00b2\",\n ylabel='$',\n prediction=prediction,\n legend=True,\n r_squared=r_2)\n```\n\n## Additional tests\n\nLet us compute a prediction for $x=650$\n\n\n\n```python\n# Let us use the prediction function\nx = np.asarray([650]).reshape(1,1)\nprediction = normal_equation_prediction(x, w)\nprint(\"Area = %.2f Predicted price = %.4f\" %(x[0], prediction))\n```\n\n Area = 650.00 Predicted price = 44470.9472\n\n\n## 1.4. Processing time \n\nExperiment with different nummber of samples $N$ and observe how processing time varies.\n\nBe careful not to use a too large value; it may make jupyter freeze ...\n\n\n```python\n# Add other values for N\n# START OF YOUR CODE:\nN = [100, 200, 500, 1000, 5000, 10000, 100000, 10000000]\n# END OF YOUR CODE\n\nfor i in N:\n X, y = get_housing_prices_data(N=i)\n init = time.time()\n w = normal_equation_weights(X, y)\n prediction = normal_equation_prediction(X,w)\n init = time.time() - init\n \n print(\"\\nExecution time = {:.8f}(s)\\n\".format(init))\n```\n\n \n X shape = (100, 1)\n y shape = (100, 1)\n \n X: mean 645.0, sdt 323.65, max 1200.00, min 90.00\n y: mean 44131.31, sdt 16462.71, max 77546.66, min 10220.15\n \n Execution time = 0.00058222(s)\n \n \n X shape = (200, 1)\n y shape = (200, 1)\n \n X: mean 645.0, sdt 322.04, max 1200.00, min 90.00\n y: mean 44643.07, sdt 16741.32, max 77416.36, min 11328.75\n \n Execution time = 0.00007701(s)\n \n \n X shape = (500, 1)\n y shape = (500, 1)\n \n X: mean 645.0, sdt 321.07, max 1200.00, min 90.00\n y: mean 44582.73, sdt 16791.18, max 83074.05, min 9172.27\n \n Execution time = 0.00033569(s)\n \n \n X shape = (1000, 1)\n y shape = (1000, 1)\n \n X: mean 645.0, sdt 320.75, max 1200.00, min 90.00\n y: mean 44441.20, sdt 16539.07, max 79329.80, min 10420.06\n \n Execution time = 0.00034523(s)\n \n \n X shape = (5000, 1)\n y shape = (5000, 1)\n \n X: mean 645.0, sdt 320.49, max 1200.00, min 90.00\n y: mean 44266.45, sdt 16549.26, max 80368.79, min 5516.63\n \n Execution time = 0.00048804(s)\n \n \n X shape = (10000, 1)\n y shape = (10000, 1)\n \n X: mean 645.0000610351562, sdt 320.46, max 1200.00, min 90.00\n y: mean 44271.82, sdt 16555.38, max 85085.10, min 3211.80\n \n Execution time = 0.00039077(s)\n \n \n X shape = (100000, 1)\n y shape = (100000, 1)\n \n X: mean 645.0000610351562, sdt 320.43, max 1200.00, min 90.00\n y: mean 44233.35, sdt 16525.27, max 85116.39, min 2534.62\n \n Execution time = 0.00301242(s)\n \n \n X shape = (10000000, 1)\n y shape = (10000000, 1)\n \n X: mean 644.9998779296875, sdt 320.43, max 1200.00, min 90.00\n y: mean 44250.33, sdt 16514.00, max 89948.86, min 199.12\n \n Execution time = 0.29421997(s)\n \n\n\n# Exercise 2 \n\nLet us test the code with $𝑑>1$. \nWe will use the data we have collected in our first class. The [file](https://edisciplinas.usp.br/pluginfile.php/5982803/course/section/6115454/QT1data.csv) can be found on e-disciplinas. \n\nLet us try to predict the weight based on one or more features.\n\n\n```python\nimport pandas as pd\n\n# load the dataset\ndf = pd.read_csv('QT1data.csv')\ndf.head()\n```\n\n\n\n\n\n\n
\n \n \n Sex \n Age \n Height \n Weight \n Shoe number \n Trouser number \n \n \n \n \n 0 \n Female \n 53 \n 154 \n 59 \n 36 \n 40 \n \n \n 1 \n Male \n 23 \n 170 \n 56 \n 40 \n 38 \n \n \n 2 \n Female \n 23 \n 167 \n 63 \n 37 \n 40 \n \n \n 3 \n Male \n 21 \n 178 \n 78 \n 40 \n 40 \n \n \n 4 \n Female \n 25 \n 153 \n 58 \n 36 \n 38 \n \n \n
\n
\n\n
\n \n \n Age \n Height \n Weight \n Shoe number \n \n \n \n \n count \n 130.000000 \n 130.000000 \n 130.000000 \n 130.000000 \n \n \n mean \n 28.238462 \n 170.684615 \n 70.238462 \n 39.507692 \n \n \n std \n 12.387042 \n 11.568491 \n 15.534809 \n 2.973386 \n \n \n min \n 3.000000 \n 100.000000 \n 15.000000 \n 24.000000 \n \n \n 25% \n 21.000000 \n 164.250000 \n 60.000000 \n 38.000000 \n \n \n 50% \n 23.000000 \n 172.000000 \n 69.500000 \n 40.000000 \n \n \n 75% \n 29.000000 \n 178.000000 \n 80.000000 \n 41.000000 \n \n \n max \n 62.000000 \n 194.000000 \n 130.000000 \n 46.000000 \n \n \n
\n
2.1. One feature ($d=1$) \n\nWe will use 'Height' as the input feature and predict the weight\n\n\n```python\nfeature_cols = ['Height']\nX = df.loc[:, feature_cols]\nX.shape\n```\n\n\n\n\n (130, 1)\n\n\n\nWrite the code for computing the following\n- compute the regression weights using $\\mathbf{X}$ and $\\mathbf{y}$\n- compute the prediction\n- compute the $R^2$ value\n- plot the regression graph (use appropriate values for the parameters of function plot_points_regression() )\n\n\n```python\n# START OF YOUR CODE:\nw = normal_equation_weights(X, y)\nprediction = normal_equation_prediction(X, w)\nr_2 = r2_score(y, prediction)\nplot_points_regression(X,\n y,\n title='Weight based on height prediction',\n xlabel=\"Height\",\n ylabel='Weight',\n prediction=prediction,\n legend=True,\n r_squared=r_2)\n# END OF YOUR CODE\n```\n\n## 2.2 - Two input features ($d=2$) \n\nNow repeat the exercise with using as input the features 'Height' and 'Shoe number'\n\n- compute the regression weights using $\\mathbf{X}$ and $\\mathbf{y}$\n- compute the prediction\n- compute and print the $R^2$ value\n\nNote that our plotting function can not be used. There is no need to do plotting here.\n\n\n```python\n# START OF YOUR CODE:\nfeature_cols = ['Height', 'Shoe number']\nX = df.loc[:, feature_cols]\n\nw = normal_equation_weights(X, y)\nprediction = normal_equation_prediction(X, w)\nr_2 = r2_score(y, prediction)\n\nprint(r_2)\n# END OF YOUR CODE\n```\n\n 0.45381183096658584\n\n\n## 2.3 - Three input features ($d=3$) \n\nNow try with three features. There is no need to do plotting here.\n- compute the regression weights using $\\mathbf{X}$ and $\\mathbf{y}$\n- compute the prediction\n- compute and print the $R^2$ value\n\n\n```python\n# START OF YOUR CODE:\nfeature_cols = ['Height', 'Shoe number', 'Age']\nX = df.loc[:, feature_cols]\n\nw = normal_equation_weights(X, y)\nprediction = normal_equation_prediction(X, w)\nr_2 = r2_score(y, prediction)\n\nprint(r_2)\n# END OF YOUR CODE\n```\n\n 0.4776499498669615\n\n\n## 2.4 - Your comments \n\nDid you observe anything interesting with varying values of $d$ ? Comment about it.\n\nYOUR COMMENT BELOW:\n\nAs you increase $d$, the $R^2$ score increases slightly.\n", "meta": {"hexsha": "18fa75b149185901c8be8c3504bacc9e16afd532", "size": 116719, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ep02_linreg_analytic.ipynb", "max_stars_repo_name": "ricardokojo/MAC0460-2021", "max_stars_repo_head_hexsha": "b5d6c85c1b35e9dba9f5443f218a85b0e0845b32", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ep02_linreg_analytic.ipynb", "max_issues_repo_name": "ricardokojo/MAC0460-2021", "max_issues_repo_head_hexsha": "b5d6c85c1b35e9dba9f5443f218a85b0e0845b32", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ep02_linreg_analytic.ipynb", "max_forks_repo_name": "ricardokojo/MAC0460-2021", "max_forks_repo_head_hexsha": "b5d6c85c1b35e9dba9f5443f218a85b0e0845b32", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 109.4924953096, "max_line_length": 34588, "alphanum_fraction": 0.816850727, "converted": true, "num_tokens": 6908, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3451052709578724, "lm_q2_score": 0.33458944125318607, "lm_q1q2_score": 0.11546857978332391}}
{"text": "\n*This notebook contains course material from [CBE30338](https://jckantor.github.io/CBE30338)\nby Jeffrey Kantor (jeff at nd.edu); the content is available [on Github](https://github.com/jckantor/CBE30338.git).\nThe text is released under the [CC-BY-NC-ND-4.0 license](https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode),\nand code is released under the [MIT license](https://opensource.org/licenses/MIT).*\n\n\n< [Realizable PID Control](http://nbviewer.jupyter.org/github/jckantor/CBE30338/blob/master/notebooks/04.05-Realizable-PID-Control.ipynb) | [Contents](toc.ipynb) | [PID Control - Laboratory](http://nbviewer.jupyter.org/github/jckantor/CBE30338/blob/master/notebooks/04.10-PID-Control.ipynb) >
.\n\n\n```python\nfrom IPython.core.display import HTML\n\n\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "1f5e5bcb6912f46ddab614d90f56698463d626b3", "size": 332560, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_stars_repo_name": "yashpatel5400/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "c88d86ec45b4590779f1b340547db50cfb2e2f51", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_issues_repo_name": "yashpatel5400/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "c88d86ec45b4590779f1b340547db50cfb2e2f51", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_forks_repo_name": "yashpatel5400/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "c88d86ec45b4590779f1b340547db50cfb2e2f51", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 264.9880478088, "max_line_length": 84576, "alphanum_fraction": 0.8915503969, "converted": true, "num_tokens": 11692, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3629692055196168, "lm_q2_score": 0.31742627204485063, "lm_q1q2_score": 0.11521596177517318}}
{"text": "```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nplt.style.use('fivethirtyeight')\n```\n\n# Definitions in Dynamics: kinematics and kinetics\n\nDynamics (and Applied Mechanics II) is the study of motion and interacting objects. Dynamic models have two sets of deinitions\n\n1. Kinematics: the study of the geometry of motion\n2. Kinetics: the study of forces, work, and impulsive components\n\n## Kinematics: the geometry of motion\n\n### Position\n\nClassical physics describes the position of an object using three\nindependent coordinates e.g. \n\n$$\\mathbf{r}_{P/O} = x\\hat{i} + y\\hat{j} + z\\hat{k}$$\n\nwhere $\\mathbf{r}_{P/O}$ is the position of point $P$ _with respect to the point\nof origin_ $O$, $x,~y,~z$ are magnitudes of distance along a\nCartesian coordinate system and $\\hat{i},~\\hat{j}$ and $\\hat{k}$ are\nunit vectors that describe three directions. \n\nA __unit vector__ is a unitless vector with a magnitude of 1. It only describes a direction. In a 3D coordinate system, you can descirbe the x-, y-, and z-axes using $\\hat{i},~\\hat{j},~and~\\hat{k}$. \n\nIn the figure below, the three unit vectors are plotted as blue arrows and a vector, $\\mathbf{v}=-1\\hat{i}+1\\hat{j}+1\\hat{k}$ is plotted in red. \n\n- the values, $[-1,~1,~1]$ are the _components_ of the vector $\\mathbf{v}$\n- _components_ depend upon the coordinate system. \n- the vector $\\mathbf{v}$ describes a magnitude, $|\\mathbf{v}| = \\sqrt{1^2+1^2+1^2}=\\sqrt{3}$ and direction, $\\hat{e} = -\\frac{1}{\\sqrt{3}}\\hat{i}+\\frac{1}{\\sqrt{3}}\\hat{j}+\\frac{1}{\\sqrt{3}}\\hat{k}$\n- _unit vectors_ help to quantify the magnitude and direction, but the vector is independent of the _unit vectors_\n\n\n```python\nax = plt.figure().add_subplot(projection='3d')\nax.quiver([0, 0, 0], [0, 0, 0], [0, 0, 0], \n [1, 0, 0], [0, 1, 0], [0, 0, 1], label = 'unit vectors')\nax.quiver(0, 0, 0,\n -1, 1, 1, colors='red', label = 'v = -1i+1j+1k')\nax.set_xlim((-2,2))\nax.set_ylim((2,-2))\nax.set_zlim((-2,2))\nax.legend()\nax.set_xlabel('x-axis')\nax.set_ylabel('y-axis')\nax.set_zlabel('z-axis')\nax.set_title('Unit vectors for x-y-z fixed coordinate system');\n```\n\n### Velocity\n\nThe velocity of an object is the change in position per length of time.\n\n\\begin{equation}\n\\mathbf{v}_{P/O} = \\frac{d\\mathbf{r}_{P/O}}{dt} = \\dot{x}\\hat{i} + \\dot{y}\\hat{j} +\n\\dot{z}\\hat{k}\n\\end{equation}\n\n> __Note:__ The notation $\\dot{x}$ and $\\ddot{x}$ is short-hand for writing out\n> $\\frac{dx}{dt}$ and $\\frac{d^2x}{dt^2}$, respectively.\n\nThe definition of velocity depends upon the change in position of all\nthree independent coordinates, where\n$\\frac{d}{dt}(x\\hat{i})=\\dot{x}\\hat{i}$. \n\n### Example - velocity given position\nYou can find velocity based upon postion, but you can only find changes\nin position with velocity. Consider tracking the motion of a car driving\ndown a road using GPS. You determine its motion and create the position,\n\n$\\mathbf{r} = x\\hat{i} +y\\hat{j}~miles$, where\n\n- $x(t) = t^2 + 3~miles$ \n- $y(t) = 3t - 1~miles$\n- and $t$ is measured in hours\n\nTo get the velocity, calculate $\\mathbf{v} = \\dot{\\mathbf{r}}$\n\n$\\mathbf{v} = (2t)\\hat{i} +3 \\hat{j}$\n\n\n```python\nt = np.linspace(0, 6, 7)\nx = t**2 + 3\ny = 3*t -1\nplt.plot(x,y,'o')\nplt.quiver(x,y,2*t, 3)\nplt.title('Position of car on road every hour'+\n '\\nvelocity shown as arrow')\nplt.axis('equal')\nplt.xlabel('x-position (m)')\nplt.ylabel('y-position (m)');\n```\n\n## Speed\n\nThe speed of an object is the\n[magnitude](https://www.mathsisfun.com/algebra/vectors.html) of the\nvelocity, \n\n$|\\mathbf{v}_{P/O}| = \\sqrt{\\mathbf{v}\\cdot\\mathbf{v}} =\n\\sqrt{\\dot{x}^2 + \\dot{y}^2 + \\dot{z}^2}$\n\nIn the example above, the speed of the car, $v$, is given by\n\n$v = |\\mathbf{v}| = \\sqrt{\\dot{x}^2+\\dot{y}^2} = \\sqrt{4t^2 +9}$\n\n## Acceleration\n\nThe acceleration of an object is the change in velocity per length of\ntime. \n\n$\\mathbf{a}_{P/O} = \\frac{d \\mathbf{v}_{P/O} }{dt} = \\ddot{x}\\hat{i} +\n\\ddot{y}\\hat{j} + \\ddot{z}\\hat{k}$\n\nwhere $\\ddot{x}=\\frac{d^2 x}{dt^2}$ and $\\mathbf{a}_{P/O}$ is the\nacceleration of point $P$ _with respect to the point of origin_ $O$. \n\n## Rotation and Orientation\n\nThe definitions of position, velocity, and acceleration all describe a\nsingle point, but dynamic engineering systems are composed of rigid\nbodies is needed to describe the position of an object. \n\n\n\n_In the figure above, the center of the block is located at\n$r_{P/O}=x\\hat{i}+y\\hat{j}$ in both the left and right images, but the\ntwo locations are not the same. The orientation of the block is\nimportant for determining the position of all the material points._\n\nIn general, a rigid body has a _pitch_, _yaw_, and _roll_ that describes\nits rotational orientation, as seen in the animation below. We will\nrevisit 3D motion in Module_05. For now, we will limit our description of \nmotion to _planar motion_. \n\n\n\n```python\nfrom IPython.display import YouTubeVideo\nvid = YouTubeVideo(\"li7t--8UZms?loop=1\")\ndisplay(vid)\n```\n\n\n\n\n\n\n\n## Planar motion: angular velocity\n\nPlanar motion means that an object's motion is described using three components:\n\n- x-position\n- y-position\n- orientation ($\\theta$)\n\nThe x-y-positions describe a point (such as the center of mass) in the object and $\\theta$ describes its rotation. The change in angle over time is called __angular velocity__\n\n- __angular velocity__ has a magnitude and direction, $\\mathbf{\\omega} = \\dot{\\theta}\\hat{k}$\n- the derivative of angular velocity is __angular acceleration__, $\\mathbf{\\alpha}=\\frac{d\\mathbf{\\omega}}{dt} = \\ddot{\\theta}\\hat{k}$\n\nNow, you can describe a planar object's motion with\n\n- position, $\\mathbf{r}=x\\hat{i}+y\\hat{j}$, and orientation $\\theta$\n- velocity, $\\mathbf{v}=\\dot{x}\\hat{i}+\\dot{y}\\hat{j}$, and angular velocity $\\mathbf{\\omega}=\\dot{\\theta}\\hat{k}$\n- acceleration, $\\mathbf{r}=\\ddot{x}\\hat{i}+\\ddot{y}\\hat{j}$, and angular acceleration $\\mathbf{\\alpha}=\\ddot{\\theta}\\hat{k}$ \n\n## Kinetics - forces, work-energy, impulse-momentum\n\n### Newton-Euler equations\n\nIn this course, you will use the Newton-Euler equations to relate motion to applied forces and moments\n\n- $\\mathbf{F} = m\\mathbf{a}$\n- $\\mathbf{M} = I\\mathbf{\\alpha}$\n\nThe Newton-Euler equations describe forces in terms of acceleration and angular acceleration. The $m$ is the mass of the object and the $I$ is the [moment of inertia](https://en.wikipedia.org/wiki/Moment_of_inertia) of the object. You can think of _moment of inertia_ as a way to measure distribution of mass, its measured in terms of $[kg\\cdot m^2]$, in SI units. \n\n### Example - changing a tire\n\nWhen you change a tire, you either need to engage the brakes or leave the tire in contact with the ground. If not, you can calculate how quickly the tire will accelerate for a an applied moment. \n\nIn this example, a $m=10~kg$, tire with moment of inertia $I =1~kg\\cdot m^2$ is able to rotate freely. The tire iron has a 10-N force on both sides, each 0.1-m from the center of the tire. \n\n- $\\sum F_x = 0 + 0 = m\\ddot{x}$\n- $\\sum F_y = 10 - 10 = m\\ddot{y}$\n- $\\sum M = 0.1\\cdot 10 + 0.1 \\cdot 10 = I\\ddot{\\theta}$\n\nBoth the acceleration components are $\\ddot{x} = \\ddot{y} = 0~m/s$. The angular acceleration is $\\ddot{\\theta}\\hat{k} = \\frac{2~N\\cdot m}{1~kg-m^2} = 2~\\frac{rad}{s^2}\\hat{k}$. \n\n### Work-Energy equations\n\n__Work__ is defined as a force acting through a distance and/or a moment acting over a given rotation, $dW=F\\cdot d\\mathbf{r}+Md\\theta$. When mechanical __work__ is added to a dynamic system, the energy of the system has to change. If you _ignore changes in temperature_, then there are two possible conversions\n\n- kinetic energy, $T = \\frac{1}{2}mv^2 + \\frac{1}{2}I\\dot{\\theta}^2$\n- potential energy, $V$\n\nThe kinetic energy quantifies the speed and mass of an object. For a solid object, like the tire from the last example, this include the _translational kinetic energy_ $\\frac{1}{2}mv^2$ and the _rotational kinetic energy_, $\\frac{1}{2}I\\dot{\\theta}^2$. The potential energy can describe work done by _conservative forces_, such as\n\n- springs, $V_{spring} = \\frac{1}{2}kx^2$, where x is distance the spring stretched and k is the spring stiffness\n- gravity _near Earth surface_, $V_{gravity} = mgh$, where $h$ is the change in height of the object\n- gravity _general_, $V_{gravity} = \\frac{GMm}{r}$, where $G=6.674\\times10^{11} \\frac{m^3}{kg \\cdot s^2}$, $M$ is mass of Earth, and $r$ is distance from Earth's center\n- ...\n\nPotential energy is independent of velocity and the path an object takes. If you raise a 5-kg bowling ball 1 meter, it has $V=mgh=(5~kg)(9.81~\\frac{m}{s^2})(1~m) = 49~J$ of potential energy. It does not matter if it was raised slowly or quickly or if it reached the height on a vertical path or angled path. \n\nThe work-energy equation satisfies the [first law of thermodynamics](https://en.wikipedia.org/wiki/First_law_of_thermodynamics): energy can neither be created or destroyed\n\n$T_1 + V_1 + W_{1\\rightarrow 2} = T_2+V_2$\n\nThis equation states that the mechanical work, $W_{1\\rightarrow 2}$, will create a change in total energy of the system, $T+V$. The subscripts $1~and~2$ describe a starting and ending point. \n\n### Example - elevator motor selection\n\nYou are an engineer asked to select an electric motor for a 1000-kg elevator. The elevator has a 1000-kg counterweight as shown below. What information do you need to select the motor?\n\n\n\nFirst, consider the work done to go from 0-30 m. \n\n$T_1 + V_1 +W_{1\\rightarrow 2} = T_2 + V_2$\n\n- $T_1 = T_2 = 0$ since the elevator and counterweight stop at 30 m and 0 m, respectively\n- $V_1 = (1000~kg)(9.81~m/s^2)(30~m)$\n- $V_2 = (1000~kg)(9.81~m/s^2)(30~m)$\n\nThis means, $W_{1\\rightarrow 2}=V_2-V_1=0~J$. How can this be?\n\nThe counterweight is there to balance the weight of the elevator, so no matter what height the elevator reaches, the work done to overcome gravity is $0~J$. Does this mean you can move the elevator with a 0-N-m motor? _not quite_. \n\nThe motor might not need to overcome gravity, but if you want to reach the top floor in a certain amount of time, you need to add kinetic energy to the system. A 30-m building is 10 stories tall. You would want to know how fast the elevator needs to travel. Let's estimate that it takes 20 seconds to go floor 1 to 10. \n\n- $T_1 = 0$\n- $v_2 = \\frac{30~m}{20~s} = 1.5~m/s$\n- $T_2 = \\frac{1}{2}(1000~kg)(1.5~m/s)^2+\\frac{1}{2}(1000~kg)(1.5~m/s)^2$\n\nNow, you have\n\n$W_{1\\rightarrow 2}=T_2-T_1=2250~J=2250~N\\cdot m$\n\nThe work done to get the elevator to its cruising speed is 2.25 kJ. When you stop, you will have to remove 2.25 kJ using the motor or a brake. Now, how _quickly_ should you start and stop? Standard practice for comfort is to [accelerate elevators](https://www.treehugger.com/how-fast-should-elevator-go-4858555#:~:text=The%20elevator%20could%20be%20going,pushing%20the%20limits%20of%20comfort.) at $1.5~m/s^2$.\n\nSo the time it takes to reach maximum speed is $\\Delta t = 1~s$. You should select a motor that creates $\\dot{W}_{1\\rightarrow 2} = \\frac{2250~J}{1~s} = 2.25~kW$ of power. \n\n### Impulse-momentum equations\n\nNewton first described the laws of motion in terms of _momentum_, $\\mathbf{p} = m\\mathbf{v}$ and force. The second law was stated as the equation\n\n$F = d(m\\mathbf{v})$\n\nThe applied force, $F$, will change the momentum, $m\\mathbf{v}$. The same equation is true for rotation of an object\n\n$M = d(\\mathbf{h})$\n\nwhere $\\mathbf{h}$ is the angular momentum of an object. In planar systems, $\\mathbf{h} = I\\dot{\\theta}\\hat{k}$. \n\nAn _impulse_ is a force or moment applied over a period of time. When there is an impact or explosion, you can use the _impulse-momentum_ equations as such\n\n- $m\\mathbf{v}_1 + \\mathbf{F}dt = m\\mathbf{v}_2$\n- $I\\dot{\\theta}_1 + \\mathbf{M}dt = I\\dot{\\theta}_2$\n\nwhere $\\mathbf{F}dt$ is the linear impulse, $\\mathbf{M}dt$ is the moment-impulse, $m\\mathbf{v}$ is linear momentum, and $I\\dot{\\theta}$ is angular momentum. \n\n### Example - hitting a golf ball\n\nWhen a golf ball is hit by a club, it goes from rest to 45 m/s (~100 mph) almost instantly. If you take the derivative of velocity to get acceleration, you have\n\n$a = \\frac{45~m/s}{0~s} = \\infty~m/s^2$\n\nwhich would mean that the applied force is [0.045~kg](https://golf.com/gear/golf-balls/how-many-dimples-on-a-golf-ball/#:~:text=But%20in%20the%20modern%20game,1.620%20ounces%2C%20or%2045.93%20grams.)$\\cdot \\infty~m/s^2=\\infty~N$. Its just not helpful information, and in reality there must be some change in time between 0 and $45~m/s$. \n\nInstead, use the _impulse-momentum_ equation to determine the _impulse_ required to change the _momentum_ of the golf ball\n\n$\\mathbf{F}dt = m\\mathbf{v}_2- m\\mathbf{v}_1 = (0.045~kg)(45~m/s) = 2.02~\\frac{kg\\cdot m}{s} = 2.02~N\\cdot s$\n\n\n\n## Wrapping up\n\nIn this notebook you defined:\n\n- Kinematics - the geometry of motion\n - position, $\\mathbf{r} = x\\hat{i}+y\\hat{j}+z\\hat{k}$\n - velocity, $\\mathbf{v} = \\frac{d\\mathbf{r}}{dt}$\n - acceleration, $\\mathbf{a} = \\frac{d\\mathbf{a}}{dt}$\n - angular velocity, $\\mathbf{\\omega} = \\dot{\\theta}\\hat{k}$ _in planar motion_\n - angular acceleration, $\\mathbf{\\alpha} = \\ddot{\\theta}\\hat{k}$ _in planar motion_\n- Kinetics - the study of forces, work-energy, and impulse-momentum\n - Newton-Euler equations: $\\mathbf{F} = m\\mathbf{a}$ and $\\mathbf{M} = \\frac{d}{dt}\\mathbf{h}$ \n - work-energy equation: $T_1+V_1 +W_{1\\rightarrow 2} = T_2 + V_2$\n - impulse-momentum equation: $m\\mathbf{v}_1 + Fdt = m\\mathbf{v}_2$ and $I\\omega_1 + Mdt = I\\omega_2$ _in planar motion\n \nEvery rigid-body dynamic problem is solved using these kinematic and kinetic equations. You will use a combination of algebra, geometry, and calculus to get final solutions, but the __core engineering concepts__ in dynamics are _kinematics_ and _kinetics_ equations. \n", "meta": {"hexsha": "d3dddfdce206788e1836186330ab835ccd2acf56", "size": 97427, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "module_01/definitions.ipynb", "max_stars_repo_name": "UConn-Cooper/engineering-dynamics", "max_stars_repo_head_hexsha": "d89a591321634905c1c0e3522a3a9f7aab5abbd3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-02-16T23:51:30.000Z", "max_stars_repo_stars_event_max_datetime": "2021-02-16T23:51:30.000Z", "max_issues_repo_path": "module_01/definitions.ipynb", "max_issues_repo_name": "UConn-Cooper/engineering-dynamics", "max_issues_repo_head_hexsha": "d89a591321634905c1c0e3522a3a9f7aab5abbd3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2021-02-16T01:25:06.000Z", "max_issues_repo_issues_event_max_datetime": "2021-06-24T20:29:00.000Z", "max_forks_repo_path": "module_01/definitions.ipynb", "max_forks_repo_name": "UConn-Cooper/engineering-dynamics", "max_forks_repo_head_hexsha": "d89a591321634905c1c0e3522a3a9f7aab5abbd3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-02-16T01:20:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-02T19:19:58.000Z", "avg_line_length": 202.9729166667, "max_line_length": 48308, "alphanum_fraction": 0.889024603, "converted": true, "num_tokens": 4405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38861804086755836, "lm_q2_score": 0.2942149783515162, "lm_q1q2_score": 0.11433724848085733}}
{"text": "# [ATM 623: Climate Modeling](../index.ipynb)\n\n[Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany\n\n# Lecture 6: Elementary greenhouse models\n\n### About these notes:\n\nThis document uses the interactive [`Jupyter notebook`](https://jupyter.org) format. The notes can be accessed in several different ways:\n\n- The interactive notebooks are hosted on `github` at https://github.com/brian-rose/ClimateModeling_courseware\n- The latest versions can be viewed as static web pages [rendered on nbviewer](http://nbviewer.ipython.org/github/brian-rose/ClimateModeling_courseware/blob/master/index.ipynb)\n- A complete snapshot of the notes as of May 2017 (end of spring semester) are [available on Brian's website](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2017/Notes/index.html).\n\n[Also here is a legacy version from 2015](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/Notes/index.html).\n\nMany of these notes make use of the `climlab` package, available at https://github.com/brian-rose/climlab\n\n\n```python\n# Ensure compatibility with Python 2 and 3\nfrom __future__ import print_function, division\n```\n\n## Contents\n\n1. [A single layer atmosphere](#section1)\n2. [Introducing the two-layer grey gas model](#section2)\n3. [Tuning the grey gas model to observations](#section3)\n4. [Level of emission](#section4)\n5. [Radiative forcing in the 2-layer grey gas model](#section5)\n6. [Radiative equilibrium in the 2-layer grey gas model](#section6)\n7. [Summary](#section7)\n\n____________\n\n\n## 4. Level of emission\n____________\n\nEven in this very simple greenhouse model, there is **no single level** at which the OLR is generated.\n\nThe three terms in our formula for OLR tell us the contributions from each level.\n\n\n```python\nOLRterms = sympy.Matrix([OLR_s, OLR_0, OLR_1])\nOLRterms\n```\n\nNow evaluate these expressions for our tuned temperature and absorptivity:\n\n\n```python\nOLRtuned = OLRterms.subs(tuned)\nOLRtuned\n```\n\nSo we are getting about 67 W m$^{-2}$ from the surface, 79 W m$^{-2}$ from layer 0, and 93 W m$^{-2}$ from the top layer.\n\nIn terms of fractional contributions to the total OLR, we have (limiting the output to two decimal places):\n\n\n```python\nsympy.N(OLRtuned / 239., 2)\n```\n\nNotice that the largest single contribution is coming from the top layer. This is in spite of the fact that the emissions from this layer are weak, because it is so cold.\n\nComparing to observations, the actual contribution to OLR from the surface is about 22 W m$^{-2}$ (or about 9% of the total), not 67 W m$^{-2}$. So we certainly don't have all the details worked out yet!\n\nAs we will see later, to really understand what sets that observed 22 W m$^{-2}$, we will need to start thinking about the spectral dependence of the longwave absorptivity.\n\n____________\n\n[Back to ATM 623 notebook home](../index.ipynb)\n
\n\n____________\n## Version information\n____________\n\n\n\n```python\n%load_ext version_information\n%version_information sympy\n```\n\n Loading extensions from ~/.ipython/extensions is deprecated. We recommend managing extensions like any other Python packages, in site-packages.\n\n\n\n\n\nSoftware Version Python 3.6.2 64bit [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] IPython 6.1.0 OS Darwin 16.7.0 x86_64 i386 64bit sympy 1.1.1 Wed Oct 11 13:31:13 2017 EDT
\n\n\n\n____________\n\n## Credits\n\nThe author of this notebook is [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n\nIt was developed in support of [ATM 623: Climate Modeling](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/), a graduate-level course in the [Department of Atmospheric and Envionmental Sciences](http://www.albany.edu/atmos/index.php)\n\nDevelopment of these notes and the [climlab software](https://github.com/brian-rose/climlab) is partially supported by the National Science Foundation under award AGS-1455071 to Brian Rose. Any opinions, findings, conclusions or recommendations expressed here are mine and do not necessarily reflect the views of the National Science Foundation.\n____________\n\n\n```python\n\n```\n", "meta": {"hexsha": "333708ed5a380687c47d4df924fff5a7b434f8a6", "size": 414971, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture06 -- Elementary greenhouse models.ipynb", "max_stars_repo_name": "EasezzZ/Climate_Modeling_Lect", "max_stars_repo_head_hexsha": "98b681933c7340c72a7c1a96caf424f225576cfb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lectures/Lecture06 -- Elementary greenhouse models.ipynb", "max_issues_repo_name": "EasezzZ/Climate_Modeling_Lect", "max_issues_repo_head_hexsha": "98b681933c7340c72a7c1a96caf424f225576cfb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture06 -- Elementary greenhouse models.ipynb", "max_forks_repo_name": "EasezzZ/Climate_Modeling_Lect", "max_forks_repo_head_hexsha": "98b681933c7340c72a7c1a96caf424f225576cfb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-02-20T03:10:31.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-20T03:10:31.000Z", "avg_line_length": 151.726142596, "max_line_length": 161360, "alphanum_fraction": 0.8697836716, "converted": true, "num_tokens": 7573, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3923368443773709, "lm_q2_score": 0.29098086621490676, "lm_q1q2_score": 0.11416251482495045}}
{"text": "# 一、马尔可夫性质\n\n 马尔科夫性质——当前的状态只和上一时刻有关，在上一时刻之前的任何状态都和我无关。我们称其符合马尔可夫性质。\n\n 具有马尔科夫性质的状态满足下面公式：\n\n $P(S_{t+1}|S_1,S_2,...,S_t) = P(S_{t+1}|S_t)$\n\n 根据公式也就是说给定当前状态$S_t$，将来的状态与t时刻之前的状态已经没有关系。\n\n# 二、马尔可夫链\n\n 马尔可夫链是指具有马尔可夫性质的随机过程。在过程中，在给定当前信息的情况下，过去的信息状态对于预测将来状态是无关的。——可以称之为马尔科夫无后效性。\n\n\n\n# 三、隐马尔可夫模型\n\n 隐马尔可夫模型(Hidden Markov Model, HMM)是一种统计模型，在语音识别、行为识别、NLP、故障诊断等领域具有高效的性能。\n\n HMM是关于时序的概率模型，描述一个含有未知参数的马尔可夫链所生成的不可观测的状态随机序列，再由各个状态生成观测随机序列的过程。\n\n HMM是一个双重随机过程---具有一定状态的隐马尔可夫链和随机的观测序列。\n\n HMM随机生成的状态随机序列被称为状态序列；每个状态生成一个观测，由此产生的观测随机序列，被称为观测序列。\n\n 举个例子来理解下hmm，我们使用输入法打字，敲出的每个字符就是观测序列，而实际我们想写的话就是隐藏序列。那不同公司的输入法都是在努力提高猜测咱们要写的话的能力。 \n\n## 1、定义\n\n\n\n\n\n 对于HMM模型，首先我们假设Q是所有可能的隐藏状态的集合，V是所有可能的观测状态的集合，即：\n\n$Q={q_1,q_2,...,q_N},V={v_1,v_2,...v_M}$ \n\n 其中，N是可能的隐藏状态数，M是所有的可能的观察状态数。\n\n 对于一个长度为T的序列，I对应的状态序列, O是对应的观察序列，即：\n\n$I={i_1,i_2,...,i_T},O={o_1,o_2,...o_T}$ \n\n 其中，任意一个隐藏状态$i_t∈Q$,任意一个观察状态$o_t∈V$\n\n HMM模型做了两个很重要的假设如下：\n\n1. 齐次马尔科夫链假设。即任意时刻的隐藏状态只依赖于它前一个隐藏状态，这个我们在MCMC(二)马尔科夫链中有详细讲述。当然这样假设有点极端，因为很多时候我们的某一个隐藏状态不仅仅只依赖于前一个隐藏状态，可能是前两个或者是前三个。但是这样假设的好处就是模型简单，便于求解。如果在时刻t的隐藏状态是$i_t=q_i$,在时刻t+1的隐藏状态是$i_{t+1}=q_j$, 则从时刻t到时刻t+1的HMM状态转移概率$a_{ij}$可以表示为：\n\n$a_{ij}=P(i_{t+1}=q_j|i_t=q_i)$ \n\n 这样$a_{ij}$可以组成马尔科夫链的状态转移矩阵A:\n \n$A=[a_{ij}]_{N×N}$ \n\n2. 观测独立性假设。即任意时刻的观察状态只仅仅依赖于当前时刻的隐藏状态，这也是一个为了简化模型的假设。如果在时刻t的隐藏状态是$i_t=q_j$, 而对应的观察状态为$o_t=v_k$, 则该时刻观察状态$v_k$在隐藏状态$q_j$下生成的概率为$b_j(k)$,满足：\n \n$b_j(k)=P(o_t=v_k|i_t=q_j)$ \n\n 这样$b_j(k)$可以组成观测状态生成的概率矩阵B:\n \n$B=[b_j(k)]_{N×M}$ \n\n 除此之外，我们需要一组在时刻t=1的隐藏状态概率分布Π:\n \n$Π=[π(i)]_N$ 其中$π(i)=P(i_1=q_i)$\n\n 一个HMM模型，可以由隐藏状态初始概率分布Π, 状态转移概率矩阵A和观测状态概率矩阵B决定。Π,A决定状态序列，B决定观测序列。因此，HMM模型可以由一个三元组λ表示如下：\n \n$λ=(A,B,Π)$ \n\n## 2、hmm能解决的问题\n\n1. 评估观察序列概率。即给定模型$λ=(A,B,Π)$和观测序列$O={o_1,o_2,...o_T}$，计算在模型$λ$下观测序列O出现的概率$P(O|λ)$。这个问题的求解需要用到前向后向算法。\n\n2. 模型参数学习问题。即给定观测序列$O={o_1,o_2,...o_T}$，估计模型$λ=(A,B,Π)$的参数，使该模型下观测序列的条件概率$P(O|λ)$最大。这个问题的求解需要用到基于EM算法的鲍姆-韦尔奇算法。\n\n3. 预测问题，也称为解码问题。即给定模型$λ=(A,B,Π)$和观测序列$O={o_1,o_2,...o_T}$，求给定观测序列条件下，最可能出现的对应的状态序列，这个问题的求解需要用到基于动态规划的维特比算法。【预测出的每一个隐状态都有N个值，每个值对应一个概率值；例如句子分词，那么就需要利用维特比算法找到整个句子的最大隐状态概率对应的隐状态路径。】\n\n# 四、评估观察序列概率\n\n## 1、求观测序列的概率\n\n这个问题是这样的。我们已知HMM模型的参数𝜆=(𝐴,𝐵,Π)。其中𝐴是隐藏状态转移概率的矩阵，𝐵是观测状态生成概率的矩阵， Π是隐藏状态的初始概率分布。同时我们也已经得到了观测序列$O =\\{o_1,o_2,...o_T\\}$,现在我们要求观测序列𝑂在模型𝜆下出现的条件概率𝑃(𝑂|𝜆)。\n \n乍一看，这个问题很简单。因为我们知道所有的隐藏状态之间的转移概率和所有从隐藏状态到观测状态生成概率，那么我们是可以暴力求解的。\n\n我们可以列举出所有可能出现的长度为𝑇的隐藏序列$I = \\{i_1,i_2,...,i_T\\}$,分布求出这些隐藏序列与观测序列$O =\\{o_1,o_2,...o_T\\}$的联合概率分布𝑃(𝑂,𝐼|𝜆)，这样我们就可以很容易的求出边缘分布𝑃(𝑂|𝜆)了。\n\n具体暴力求解的方法是这样的：首先，任意一个隐藏序列$I = \\{i_1,i_2,...,i_T\\}$出现的概率是：\n\n$$P(I|\\lambda) = \\pi_{i_1} a_{i_{1}i_{2}} a_{i_{2}i_{3}}... a_{i_{T-1}\\;\\;i_T}$$\n\n对于固定的状态序列$I = \\{i_1,i_2,...,i_T\\}$，我们要求的观察序列$O =\\{o_1,o_2,...o_T\\}$出现的概率是：\n\n$$P(O|I, \\lambda) = b_{i_1}(o_1)b_{i_2}(o_2)...b_{i_T}(o_T)$$\n\n则𝑂和𝐼联合出现的概率是：\n\n$$P(O,I|\\lambda) = P(I|\\lambda)P(O|I, \\lambda) = \\pi_{i_1}b_{i_1}(o_1)a_{i_1i_2}b_{i_2}(o_2)...a_{i_{T-1}\\;\\;i_T}b_{i_T}(o_T)$$\n\n然后求边缘概率分布，即可得到观测序列𝑂在模型𝜆下出现的条件概率𝑃(𝑂|𝜆)，但是我们需要计算所有的T个隐状态、N种隐状态的自由组合，即$T^N$种组合的概率然后累加：\n\n>边缘分布（Marginal Distribution）指在概率论和统计学的多维随机变量中，只包含其中部分变量的概率分布。\\\n>\\\n>**定义** \\\n>假设有一个和两个变量相关的概率分布：\\\n>$P(x,y)$\\\n>关于其中一个特定变量的边缘分布则为给定其他变量的条件概率分布：\\\n>$P(x)=\\sum_yP(x,y)=\\sum_yP(x|y)P(y)$ \\\n>解释：让y取所有的可能值，然后求出只有x变量的概率；举个例子：x为肤色（黑、白、黄）y为性别（男、女）那么$P(x)=P(x|男)+P(x|女)$ \\\n>参阅Wikipedia举例，下图中，X和Y遵从绿圈内所示的二元正态分布，红线和蓝线分别表示Y变量和X变量的边缘分布 \\\n>\n>在这个边缘分布中，我们得到只关于一个变量的概率分布，而不再考虑另一变量的影响，实际上进行了降维操作。在实际应用中，例如人工神经网络的神经元互相关联，在计算它们各自的参数的时候，就会使用边缘分布计算得到某一特定神经元（变量）的值。\n\n$$P(O|\\lambda) = \\sum\\limits_{I}P(O,I|\\lambda) = \\sum\\limits_{i_1,i_2,...i_T}\\pi_{i_1}b_{i_1}(o_1)a_{i_1i_2}b_{i_2}(o_2)...a_{i_{T-1}\\;\\;i_T}b_{i_T}(o_T)$$\n\n虽然上述方法有效，但是如果我们的隐藏状态数𝑁非常多的那就麻烦了，此时我们预测状态有$N^T$种组合，算法的时间复杂度是$𝑂(𝑇𝑁^𝑇)$阶的。因此对于一些隐藏状态数极少的模型，我们可以用暴力求解法来得到观测序列出现的概率，但是如果隐藏状态多，则上述算法太耗时，我们需要寻找其他简洁的算法。\n\n前向后向算法就是来帮助我们在较低的时间复杂度情况下求解这个问题\n\n# 2、前向算法求HMM观测序列的概率\n\n前向后向算法是前向算法和后向算法的统称，这两个算法都可以用来求HMM观测序列的概率。我们先来看看前向算法是如何求解这个问题的。\n\n前向算法本质上属于动态规划的算法，也就是我们要通过找到局部状态递推的公式，这样一步步的从子问题的最优解拓展到整个问题的最优解。\n\n在前向算法中，通过定义“前向概率”来定义动态规划的这个局部状态。什么是前向概率呢, 其实定义很简单：定义时刻𝑡时隐藏状态为$q_i$, 观测状态的序列为$𝑜_1,𝑜_2,...𝑜_𝑡$的概率为前向概率。记为： \n\n$$\\alpha_t(i) = P(o_1,o_2,...o_t, i_t =q_i | \\lambda)\\ \\ \\ \\ 注意：字母是alpha不是a$$\n\n既然是动态规划，我们就要递推了，现在我们假设我们已经找到了在时刻𝑡时各个隐藏状态的前向概率，现在我们需要递推出时刻𝑡+1时各个隐藏状态的前向概率。\n\n\n\n从上图可以看出，我们可以基于时刻𝑡时各个隐藏状态的前向概率，再乘以对应的状态转移概率，即$\\alpha_t(j)a_{ji}$就是在时刻𝑡观测到$o_1,o_2,...o_t$，并且时刻𝑡隐藏状态$𝑞_𝑗$, 时刻𝑡+1隐藏状态$𝑞_i$的概率。表示为：\n\n$$P(o_1,o_2,...o_t,i_t=q_j,i_{t+1}=q_i|\\lambda)=\\alpha_t(j)a_{ji}$$\n\n如果将想上面所有的线对应的概率求和，即$\\sum\\limits_{j=1}^N\\alpha_t(j)a_{ji}$就是在时刻𝑡观测到$o_1,o_2,...o_t$，并且时刻𝑡+1隐藏状态$𝑞_i$的概率。表示为：\n\n$$P(o_1,o_2,...o_t,i_{t+1}=q_i|\\lambda)=\\sum\\limits_{j=1}^N\\alpha_t(j)a_{ji}$$\n\n继续一步，由于观测状态$O_{𝑡+1}$只依赖于𝑡+1时刻隐藏状态$𝑞_𝑖$, 这样$[\\sum\\limits_{j=1}^N\\alpha_t(j)a_{ji}]b_i(o_{t+1})$就是在在时刻𝑡+1观测到$o_1,o_2,...o_t，o_{t+1}$，并且时刻𝑡+1隐藏状态𝑞𝑖的概率。表示为：\n\n$$P(o_1,o_2,...o_t,o_{t+1},i_{t+1}=q_i|\\lambda)=[\\sum\\limits_{j=1}^N\\alpha_t(j)a_{ji}]b_i(o_{t+1})$$\n\n而这个概率，恰恰就是时刻𝑡+1对应的隐藏状态𝑖的前向概率，这样我们得到了前向概率的递推关系式如下：\n\n$$\\alpha_{t+1}(i) = \\Big[\\sum\\limits_{j=1}^N\\alpha_t(j)a_{ji}\\Big]b_i(o_{t+1})$$\n\n\n我们的动态规划从时刻1开始，到时刻𝑇结束，由于$\\alpha_T(i)$表示在时刻𝑇观测序列为$o_1,o_2,...o_T$，并且时刻𝑇隐藏状态$𝑞_𝑖$的概率，我们只要将所有隐藏状态对应的概率相加，即$\\sum\\limits_{i=1}^N\\alpha_T(i)$就得到了在时刻𝑇观测序列为$o_1,o_2,...o_T$的概率。\n\n下面总结下前向算法。\n\n输入：HMM模型𝜆=(𝐴,𝐵,Π)，观测序列𝑂=($o_1,o_2,...o_T$)\n\n输出：观测序列概率𝑃(𝑂|𝜆)\n\n1) 计算时刻1的各个隐藏状态前向概率：\n\n$$\\alpha_1(i) = \\pi_ib_i(o_1),\\; i=1,2,...N$$\n\n2) 递推时刻2,3,...𝑇时刻的前向概率（递推关系从时刻1往时刻T推，由t时刻的前向概率可以求出t+1时刻的前向概率）：\n\n$$\\alpha_{t+1}(i) = \\Big[\\sum\\limits_{j=1}^N\\alpha_t(j)a_{ji}\\Big]b_i(o_{t+1}),\\; i=1,2,...N$$\n\n3) 计算最终结果：\n\n$$P(O|\\lambda) = \\sum\\limits_{i=1}^N\\alpha_T(i)$$\n\n从递推公式可以看出，我们的算法时间复杂度是$𝑂(𝑇𝑁^2)$，比暴力解法的时间复杂度$𝑂(𝑇𝑁^𝑇)$少了几个数量级。\n\n\n\n## 3、HMM前向算法求解实例\n\n\n我们的观察集合是:\n\n$$𝑉={红，白}，𝑀=2$$\n\n我们的状态集合是：\n\n$$𝑄=\\{盒子1，盒子2，盒子3\\}，𝑁=3$$\n\n而观察序列和状态序列的长度为3.\n\n初始状态分布为：\n\n$$\\Pi = (0.2,0.4,0.4)^T$$\n\n状态转移概率分布矩阵为：\n\n$$A = \\left( \\begin{array} {ccc} 0.5 & 0.2 & 0.3 \\\\ 0.3 & 0.5 & 0.2 \\\\ 0.2 & 0.3 &0.5 \\end{array} \\right)$$\n\n观测状态概率矩阵为：\n\n$$B = \\left( \\begin{array} {ccc} 0.5 & 0.5 \\\\ 0.4 & 0.6 \\\\ 0.7 & 0.3 \\end{array} \\right)$$\n\n球的颜色的观测序列:\n\n$$O=\\{红，白，红\\}$$\n\n首先计算时刻1三个状态的前向概率：\n\n时刻1是红色球，隐藏状态是盒子1的概率为：\n\n$$\\alpha_1(1) = \\pi_1b_1(o_1) = 0.2 \\times 0.5 = 0.1$$\n\n隐藏状态是盒子2的概率为：\n\n$$\\alpha_1(2) = \\pi_2b_2(o_1) = 0.4 \\times 0.4 = 0.16$$\n\n隐藏状态是盒子3的概率为：\n\n$$\\alpha_1(3) = \\pi_3b_3(o_1) = 0.4 \\times 0.7 = 0.28$$\n\n现在我们可以开始递推了，首先递推时刻2三个状态的前向概率：\n时刻2是白色球，隐藏状态是盒子1的概率为：\n\n$$\\alpha_2(1) = \\Big[\\sum\\limits_{i=1}^3\\alpha_1(i)a_{i1}\\Big]b_1(o_2) = [0.1*0.5+0.16*0.3+0.28*0.2 ] \\times 0.5 = 0.077$$\n\n隐藏状态是盒子2的概率为：\n\n$$\\alpha_2(2) = \\Big[\\sum\\limits_{i=1}^3\\alpha_1(i)a_{i2}\\Big]b_2(o_2) = [0.1*0.2+0.16*0.5+0.28*0.3 ] \\times 0.6 = 0.1104$$\n\n隐藏状态是盒子3的概率为：\n\n$$\\alpha_2(3) = \\Big[\\sum\\limits_{i=1}^3\\alpha_1(i)a_{i3}\\Big]b_3(o_2) = [0.1*0.3+0.16*0.2+0.28*0.5 ] \\times 0.3 = 0.0606$$\n\n继续递推，现在我们递推时刻3三个状态的前向概率：\n时刻3是红色球，隐藏状态是盒子1的概率为：\n\n$$\\alpha_3(1) = \\Big[\\sum\\limits_{i=1}^3\\alpha_2(i)a_{i1}\\Big]b_1(o_3) = [0.077*0.5+0.1104*0.3+0.0606*0.2 ] \\times 0.5 = 0.04187$$\n\n隐藏状态是盒子2的概率为：\n\n$$\\alpha_3(2) = \\Big[\\sum\\limits_{i=1}^3\\alpha_2(i)a_{i2}\\Big]b_2(o_3) = [0.077*0.2+0.1104*0.5+0.0606*0.3 ] \\times 0.4 = 0.03551$$\n\n隐藏状态是盒子3的概率为：\n\n$$\\alpha_3(3) = \\Big[\\sum\\limits_{i=1}^3\\alpha_2(i)a_{i3}\\Big]b_3(o_3) = [0.077*0.3+0.1104*0.2+0.0606*0.5 ] \\times 0.7 = 0.05284$$\n\n最终我们求出观测序列:$𝑂=\\{红，白，红\\}$的概率为：\n\n$$P(O|\\lambda) = \\sum\\limits_{i=1}^3\\alpha_3(i) = 0.13022$$\n\n\n## 4、后向算法求HMM观测序列的概率\n\n后向算法和前向算法非常类似，都是用的动态规划，唯一的区别是选择的局部状态不同，后向算法用的是“后向概率”，那么后向概率是如何定义的呢？\n\n定义时刻𝑡时隐藏状态为$𝑞_𝑖$, 从时刻𝑡+1到最后时刻𝑇的观测状态的序列为$𝑜_{𝑡+1},𝑜_{𝑡+2},...𝑜_𝑇$的概率为后向概率。记为： \n\n$$\\beta_t(i) = P(o_{t+1},o_{t+2},...o_T| i_t =q_i , \\lambda)$$\n\n\n\n后向概率的动态规划递推公式和前向概率是相反的。现在我们假设我们已经找到了在时刻𝑡+1时各个隐藏状态的后向概率$𝛽_{𝑡+1}(𝑗)$，表示为：\n\n$$\\beta_{t+1}(j) = P(o_{t+2},o_{t+3}...o_T| i_{t+1} =q_j , \\lambda)$$\n\n现在我们需要递推出时刻𝑡时各个隐藏状态的后向概率。如上图，我们可以计算出观测状态的序列为$o_{𝑡+2},o_{𝑡+3},...o_𝑇$， 𝑡时隐藏状态为$𝑞_𝑖$, 时刻𝑡+1隐藏状态为$𝑞_𝑗$的概率为$𝑎_{𝑖𝑗}𝛽_{𝑡+1}(𝑗)$, 表示为：\n\n$$P(o_{𝑡+2},o_{𝑡+3},...o_𝑇|i_t=q_i,i_{t+1}=q_j,\\lambda)=𝑎_{𝑖𝑗}𝛽_{𝑡+1}(𝑗)$$\n\n接着可以得到观测状态的序列为$o_{𝑡+1},o_{𝑡+2},...o_𝑇$， 𝑡时隐藏状态为$𝑞_𝑖$, 时刻𝑡+1隐藏状态为$𝑞_𝑗$的概率为$a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)$, 表示为：\n\n$$P(o_{𝑡+1},o_{𝑡+2},...o_𝑇|i_t=q_i,i_{t+1}=q_j,\\lambda)=a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)$$\n\n则把上面所有线对应的概率加起来，我们可以得到观测状态的序列为$o_{𝑡+1},o_{𝑡+2},...o_𝑇$， 𝑡时隐藏状态为$𝑞_𝑖$的概率为$\\sum\\limits_{j=1}^{N}a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)$，这个概率即为时刻𝑡的后向概率。表示为：\n\n$$P(o_{𝑡+1},o_{𝑡+2},...o_𝑇|i_t=q_i,\\lambda)=\\sum\\limits_{j=1}^{N}a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)$$\n\n这样我们得到了后向概率的递推关系式如下：\n$$\\beta_{t}(i) = \\sum\\limits_{j=1}^{N}a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)$$\n现在我们总结下后向算法的流程,注意下和前向算法的相同点和不同点：\n\n输入：HMM模型𝜆=(𝐴,𝐵,Π)，观测序列$O=(o_1,o_2,...o_T)$\n\n输出：观测序列概率𝑃(𝑂|𝜆)\n\n1) 初始化时刻𝑇的各个隐藏状态后向概率：\n\n$$\\beta_T(i) = 1,\\; i=1,2,...N$$\n\n2) 递推时刻𝑇−1,𝑇−2,...1时刻的后向概率（递推关系从T时刻往T-1,T-2...1时刻推，利用t+1时刻的后向概率可以求t时刻的后向概率）：\n\n$$\\beta_{t}(i) = \\sum\\limits_{j=1}^{N}a_{ij}b_j(o_{t+1})\\beta_{t+1}(j),\\; i=1,2,...N$$\n\n3) 计算最终结果：\n\n$$P(O|\\lambda) = \\sum\\limits_{i=1}^N\\pi_ib_i(o_1)\\beta_1(i)$$\n\n此时我们的算法时间复杂度仍然是$𝑂(𝑇𝑁^2)$。\n\n## 5、HMM常用概率的计算\n\n利用前向概率和后向概率，我们可以计算出HMM中单个状态和两个状态的概率公式。\n\n1.给定模型𝜆和观测序列𝑂,在时刻𝑡处于状态$𝑞_𝑖$的概率记为:\n\n$$\\gamma_t(i) = P(i_t = q_i | O,\\lambda) = \\frac{P(i_t = q_i ,O|\\lambda)}{P(O|\\lambda)}$$\n\n那么$P(i_t = q_i ,O|\\lambda)$怎么求呢？\n\n我们先分析下这个概率求的是啥，\n\n它的意思是:在给定HMM的参数λ，观测序列是$O(O_1,O_2,...O_T)$,在t时刻的状态为$q_i$的概率。\n\n换句话理解就是:从1到t时刻，t时刻的状态为$q_i$,输出是$O(O_1,O_2,...O_T)$的概率P1；然后t时刻之后到T，在t时刻状态为$q_i$的基础上，输出序列是$o_{t+1},o_{t+2}..o_T$的概率P2，P1和P2相乘即为所求。\n\n碰巧P1符合前向概率定义，P2符合后向概率定义，所以 $P1=\\alpha_t(i) \\ \\ \\ P2=\\beta_t(i)$，则:\n\n$$P(i_t = q_i ,O|\\lambda) = P1*P2 = \\alpha_t(i)\\beta_t(i)$$\n\n那么：\n\n$$P(O|\\lambda) = \\sum_j^N \\alpha_t(j)\\beta_t(j) \\ \\ \\ 注意：为啥P(O|\\lambda)用这个表示，因为这样方便计算$$\n\n所以：\n\n$$\\gamma_t(i) = \\frac{ \\alpha_t(i)\\beta_t(i)}{\\sum\\limits_{j=1}^N \\alpha_t(j)\\beta_t(j)}$$\n\n2.给定模型𝜆和观测序列𝑂,在时刻𝑡处于状态$𝑞_𝑖$，且时刻𝑡+1处于状态$𝑞_𝑗$的概率记为:\n\n$$\\xi_t(i,j) = P(i_t = q_i, i_{t+1}=q_j | O,\\lambda) = \\frac{ P(i_t = q_i, i_{t+1}=q_j , O|\\lambda)}{P(O|\\lambda)}$$\n\n那么$P(i_t = q_i, i_{t+1}=q_j , O|\\lambda)$怎么求呢？\n\n我们先分析下这个概率求的是啥，\n\n它的意思是：在给定HMM的参数下，观测序列是O，t时刻的状态是$q_i$，t+1时刻的状态是$q_j$的概率。\n\n这个概率=$P(O_1,O_2,...O_t,i_t=q_i|λ)*P(q_i转移到t+1时刻的q_j)*P(o_{t+2},o_{t+3}..o_T|i_{t+1}=q_j, λ)*P(t+1时刻输出是O_{t+1})$\n\n逐个解释下：\n\n>$P(O_1,O_2,...O_t,i_t=q_i|λ)$:这不就是t时刻的前向概率$\\alpha_t(i)$么\\\n>$P(q_i转移到t+1时刻的q_j)$:这不就是转移概率$a_{ij}$么\\\n>$P(o_{t+2},o_{t+3}..o_T|i_{t+1}=q_j, λ)$:这不就是t+1时刻的后向概率$\\beta_{t+1}(i)$么\\\n>(注意:t+1时刻的后续输出序列是$o_{t+2},o_{t+3}..o_T$,即下标是从t+2开始，不是t+1开始，请仔细理解后向概率的定义)。\\\n>前面少了$O_{t+1}$这个时间点的观测序列，因此要补上$P(t+1时刻输出是O_{t+1})$,而这个不就是$b_{j}(O_{t+1})$么\n\n所以：\n\n$$P(i_t = q_i, i_{t+1}=q_j , O|\\lambda) = \\alpha_t(i)a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)$$\n\n所以：\n\n$$P(O|\\lambda)=\\sum\\limits_{r=1}^N\\sum\\limits_{s=1}^N\\alpha_t(r)a_{rs}b_s(o_{t+1})\\beta_{t+1}(s)$$\n\n所以：\n\n$$\\xi_t(i,j) = \\frac{\\alpha_t(i)a_{ij}b_j(o_{t+1})\\beta_{t+1}(j)}{\\sum\\limits_{r=1}^N\\sum\\limits_{s=1}^N\\alpha_t(r)a_{rs}b_s(o_{t+1})\\beta_{t+1}(s)}$$\n\n3.将$𝛾_𝑡(𝑖)$和$𝜉_𝑡(𝑖,𝑗)$在各个时刻𝑡求和，可以得到：\n\n在观测序列𝑂下状态𝑖出现的期望值$\\sum_{𝑡=1}^𝑇𝛾_𝑡(𝑖)$\n\n在观测序列𝑂下由状态𝑖转移的期望值$\\sum_{𝑡=1}^{𝑇-1}𝛾_𝑡(𝑖)$\n\n在观测序列𝑂下由状态𝑖转移到状态𝑗的期望值$\\sum_{𝑡=1}^{𝑇-1}𝜉_𝑡(𝑖,𝑗)$\n\n\n# 五、模型参数学习问题\n\n## 1、HMM模型参数求解概述\n\nHMM模型参数求解根据已知的条件可以分为两种情况。\n\n第一种情况较为简单，就是我们已知𝐷个长度为𝑇的观测序列和对应的隐藏状态序列，即${(𝑂_1,𝐼_1),(𝑂_2,𝐼_2),...(𝑂_𝐷,𝐼_𝐷)}$是已知的，此时我们可以很容易的用最大似然来求解模型参数。\n\n假设样本从隐藏状态$𝑞_𝑖$转移到$𝑞_𝑗$的频率计数是$𝐴_{𝑖𝑗}$,那么状态转移矩阵求得为：\n\n$$A = \\Big[a_{ij}\\Big], \\;其中a_{ij} = \\frac{A_{ij}}{\\sum\\limits_{s=1}^{N}A_{is}}$$\n\n假设样本隐藏状态为$𝑞_𝑗$且观测状态为$𝑣_𝑘$的频率计数是$𝐵_{𝑗𝑘}$,那么观测状态概率矩阵为：\n\n$$B= \\Big[b_{j}(k)\\Big], \\;其中b_{j}(k) = \\frac{B_{jk}}{\\sum\\limits_{s=1}^{M}B_{js}}$$\n\n假设所有样本中初始隐藏状态为$𝑞_𝑖$的频率计数为$𝐶(𝑖)$,那么初始概率分布为：\n\n$$\\Pi = \\pi(i) = \\frac{C(i)}{\\sum\\limits_{s=1}^{N}C(s)}$$\n\n可见第一种情况下求解模型还是很简单的。但是在很多时候，我们无法得到HMM样本观察序列对应的隐藏序列，只有𝐷个长度为𝑇的观测序列，即${(𝑂_1),(𝑂_2),...(𝑂_𝐷)}$是已知的，此时我们能不能求出合适的HMM模型参数呢？这就是我们的第二种情况，也是我们本文要讨论的重点。它的解法最常用的是鲍姆-韦尔奇算法，其实就是基于EM算法的求解，只不过鲍姆-韦尔奇算法出现的时代，EM算法还没有被抽象出来，所以我们本文还是说鲍姆-韦尔奇算法。\n\n\n## 2、鲍姆-韦尔奇（Baum-Welch）算法原理\n\n 鲍姆-韦尔奇算法原理既然使用的就是EM算法【（Expectation-Maximum）算法也称期望最大化算法】的原理，那么我们需要在E步求出联合分布𝑃(𝑂,𝐼|𝜆)基于条件概率$P(I|O,\\overline{\\lambda})$的期望，其中$\\overline{\\lambda}$为当前的模型参数，然后再M步最大化这个期望，得到更新的模型参数𝜆。接着不停的进行EM迭代，直到模型参数的值收敛为止。\n\n首先来看看E步，当前模型参数为$\\overline{\\lambda}$, 联合分布𝑃(𝑂,𝐼|𝜆)基于条件概率$P(I|O,\\overline{\\lambda})$的期望表达式为：\n\n$$L(\\lambda, \\overline{\\lambda}) = \\sum\\limits_{I}P(I|O,\\overline{\\lambda})logP(O,I|\\lambda)$$\n\n在M步，我们极大化上式，然后得到更新后的模型参数如下： \n\n$$\\overline{\\lambda} = arg\\;\\max_{\\lambda}\\sum\\limits_{I}P(I|O,\\overline{\\lambda})logP(O,I|\\lambda)$$\n\n通过不断的E步和M步的迭代，直到$\\overline{\\lambda}$收敛。下面我们来看看鲍姆-韦尔奇算法的推导过程。\n\n## 3、鲍姆-韦尔奇算法的推导\n\n我们的训练数据为$\\{(O_1, I_1), (O_2, I_2), ...(O_D, I_D)\\}$，其中任意一个观测序列$O_d = \\{o_1^{(d)}, o_2^{(d)}, ... o_T^{(d)}\\}$,其对应的未知的隐藏状态序列表示为：$I_d = \\{i_1^{(d)}, i_2^{(d)}, ... i_T^{(d)}\\}$\n\n首先看鲍姆-韦尔奇算法的E步，我们需要先计算联合分布$𝑃(𝑂,𝐼|\\lambda)$的表达式如下：\n\n$$P(O,I|\\lambda) = \\prod_{d=1}^D \\pi_{i_1^{(d)}}\\ b_{i_1^{(d)}}\\ (o_1^{(d)})\\ a_{i_1^{(d)}\\ i_2^{(d)}}\\ b_{i_2^{(d)}}\\ (o_2^{(d)}) ... a_{i_{T-1}^{(d)} \\ \\ i_T^{(d)}}\\ b_{i_T^{(d)}}\\ \\ (o_T^{(d)})$$\n\n我们的E步得到的期望表达式为：\n\n$$L(\\lambda, \\overline{\\lambda}) = \\sum\\limits_{I}P(I|O,\\overline{\\lambda})logP(O,I|\\lambda)$$\n\n在M步我们要极大化上式。由于$P(I|O,\\overline{\\lambda}) = \\frac{P(I,O|\\overline{\\lambda})}{P(O|\\overline{\\lambda})}$,而$𝑃(𝑂|\\overline{\\lambda})$是常数，因此我们要极大化的式子等价于：\n\n$$\\overline{\\lambda} = arg\\;\\max_{\\lambda}\\sum\\limits_{I}P(O,I|\\overline{\\lambda})logP(O,I|\\lambda)$$\n\n我们将上面$𝑃(𝑂,𝐼|𝜆)$的表达式带入我们的极大化式子，得到的表达式如下：\n\n$$\\overline{\\lambda} = arg\\;\\max_{\\lambda}\\sum\\limits_{d=1}^D\\sum\\limits_{I}P(O,I|\\overline{\\lambda})(log\\pi_{i_1} + \\sum\\limits_{t=1}^{T-1}log\\;a_{i_t,i_{t+1}} + \\sum\\limits_{t=1}^Tlog b_{i_t}(o_t))$$\n\n我们的隐藏模型参数$𝜆=(𝐴,𝐵,Π)$,因此下面我们只需要对上式分别对$𝐴,𝐵,Π$求导即可得到我们更新的模型参数$\\overline{\\lambda}$\n\n首先我们看看对模型参数Π的求导。由于Π只在上式中括号里的第一部分出现，因此我们对于Π的极大化式子为：\n\n$$\\overline{\\pi_i} = arg\\;\\max_{\\pi_{i_1}} \\sum\\limits_{d=1}^D\\sum\\limits_{I}P(O,I|\\overline{\\lambda})log\\pi_{i_1} = arg\\;\\max_{\\pi_{i}} \\sum\\limits_{d=1}^D\\sum\\limits_{i=1}^NP(O,i_1^{(d)} =i|\\overline{\\lambda})log\\pi_{i}$$\n\n由于$𝜋_𝑖$还满足$\\sum\\limits_{i=1}^N\\pi_i =1$，因此根据拉格朗日子乘法，我们得到𝜋𝑖要极大化的拉格朗日函数为：\n\n$$arg\\;\\max_{\\pi_{i}}\\sum\\limits_{d=1}^D\\sum\\limits_{i=1}^NP(O,i_1^{(d)} =i|\\overline{\\lambda})log\\pi_{i} + \\gamma(\\sum\\limits_{i=1}^N\\pi_i -1)$$\n\n其中，𝛾为拉格朗日系数。上式对$𝜋_𝑖$求偏导数并令结果为0， 我们得到：\n\n$$\\sum\\limits_{d=1}^DP(O,i_1^{(d)} =i|\\overline{\\lambda}) + \\gamma\\pi_i = 0$$\n\n令𝑖分别等于从1到𝑁，从上式可以得到𝑁个式子，对这𝑁个式子求和可得：\n\n$$\\sum\\limits_{d=1}^DP(O|\\overline{\\lambda}) + \\gamma = 0$$\n\n从上两式消去𝛾,得到$𝜋_𝑖$的表达式为：\n\n$$\\pi_i =\\frac{\\sum\\limits_{d=1}^DP(O,i_1^{(d)} =i|\\overline{\\lambda})}{\\sum\\limits_{d=1}^DP(O|\\overline{\\lambda})} = \\frac{\\sum\\limits_{d=1}^DP(O,i_1^{(d)} =i|\\overline{\\lambda})}{DP(O|\\overline{\\lambda})} = \\frac{\\sum\\limits_{d=1}^DP(i_1^{(d)} =i|O, \\overline{\\lambda})}{D} = \\frac{\\sum\\limits_{d=1}^DP(i_1^{(d)} =i|O^{(d)}, \\overline{\\lambda})}{D}$$\n\n利用前向概率的定义可得：\n\n$$P(i_1^{(d)} =i|O^{(d)}, \\overline{\\lambda}) = \\gamma_1^{(d)}(i)$$\n\n因此最终我们在M步$𝜋_𝑖$的迭代公式为：\n\n$$\\pi_i = \\frac{\\sum\\limits_{d=1}^D\\gamma_1^{(d)}(i)}{D}$$\n\n现在我们来看看𝐴的迭代公式求法。方法和Π的类似。由于𝐴只在最大化函数式中括号里的第二部分出现，而这部分式子可以整理为：\n\n$$\\sum\\limits_{d=1}^D\\sum\\limits_{I}\\sum\\limits_{t=1}^{T-1}P(O,I|\\overline{\\lambda})log\\;a_{i_t,i_{t+1}} = \\sum\\limits_{d=1}^D\\sum\\limits_{i=1}^N\\sum\\limits_{j=1}^N\\sum\\limits_{t=1}^{T-1}P(O,i_t^{(d)} = i, i_{t+1}^{(d)} = j|\\overline{\\lambda})log\\;a_{ij}$$\n\n由于$𝑎_{𝑖𝑗}$还满足$\\sum\\limits_{j=1}^Na_{ij} =1$。和求解𝜋𝑖类似，我们可以用拉格朗日子乘法并对$𝑎_{𝑖𝑗}$求导，并令结果为0，可以得到$𝑎_{𝑖𝑗}$的迭代表达式为：\n\n$$a_{ij} = \\frac{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T-1}P(O^{(d)}, i_t^{(d)} = i, i_{t+1}^{(d)} = j|\\overline{\\lambda})}{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T-1}P(O^{(d)}, i_t^{(d)} = i|\\overline{\\lambda})}$$\n\n利用前向概率的定义和$𝜉𝑡(𝑖,𝑗)$的定义可得到在M步$𝑎_{𝑖𝑗}$的迭代公式为：\n\n$$a_{ij} = \\frac{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T-1}\\xi_t^{(d)}(i,j)}{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T-1}\\gamma_t^{(d)}(i)}$$\n\n现在我们来看看𝐵的迭代公式求法。方法和Π的类似。由于𝐵只在最大化函数式中括号里的第三部分出现，而这部分式子可以整理为：\n\n$$\\sum\\limits_{d=1}^D\\sum\\limits_{I}\\sum\\limits_{t=1}^{T}P(O,I|\\overline{\\lambda})log\\;b_{i_t}(o_t) = \\sum\\limits_{d=1}^D\\sum\\limits_{j=1}^N\\sum\\limits_{t=1}^{T}P(O,i_t^{(d)} = j|\\overline{\\lambda})log\\;b_{j}(o_t)$$\n\n由于$𝑏_𝑗(𝑜_𝑡)$还满足$\\sum_{𝑘=1}^𝑀𝑏_𝑗(𝑜_𝑡=𝑣_𝑘)=1$。和求解$𝜋_𝑖$类似，我们可以用拉格朗日子乘法并对$𝑏_𝑗(𝑘)$求导，并令结果为0，得到$𝑏_𝑗(𝑘)$的迭代表达式为：\n\n$$b_{j}(k) = \\frac{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T}P(O,i_t^{(d)} = j|\\overline{\\lambda})I(o_t^{(d)}=v_k)}{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T}P(O,i_t^{(d)} = j|\\overline{\\lambda})}$$\n\n其中$𝐼(𝑜_t^{(𝑑)}=𝑣_𝑘)$当且仅当$𝑜_t^{(𝑑)}=𝑣_𝑘$时为1，否则为0. 利用前向概率的定义可得$𝑏_𝑗(𝑜_𝑡)$的最终表达式为：\n\n$$b_{j}(k) = \\frac{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1, o_t^{(d)}=v_k}^{T}\\gamma_t^{(d)}(j)}{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T}\\gamma_t^{(d)}(j)}$$\n\n有了$𝜋_𝑖,𝑎_{𝑖𝑗},𝑏_𝑗(𝑘)$的迭代公式，我们就可以迭代求解HMM模型参数了。\n\n## 4、鲍姆-韦尔奇算法流程总结\n\n概括总结下鲍姆-韦尔奇算法的流程。\n\n**输入：** 𝐷个观测序列样本${(𝑂_1),(𝑂_2),...(𝑂_𝐷)}$\n\n**输出：** HMM模型参数\n\n1)随机初始化所有的$𝜋_𝑖,𝑎_{𝑖𝑗},𝑏_𝑗(𝑘)$\n\n2)对于每个样本𝑑=1,2,...𝐷，用前向后向算法计算$\\gamma_t^{(d)}(i)，\\xi_t^{(d)}(i,j), t =1,2...T$\n\n3)更新模型参数：\n\n$$\\pi_i = \\frac{\\sum\\limits_{d=1}^D\\gamma_1^{(d)}(i)}{D}$$\n\n$$a_{ij} = \\frac{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T-1}\\xi_t^{(d)}(i,j)}{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T-1}\\gamma_t^{(d)}(i)}$$\n\n$$b_{j}(k) = \\frac{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1, o_t^{(d)}=v_k}^{T}\\gamma_t^{(d)}(j)}{\\sum\\limits_{d=1}^D\\sum\\limits_{t=1}^{T}\\gamma_t^{(d)}(j)}$$\n\n4)如果$𝜋_𝑖,𝑎_{𝑖𝑗,}𝑏_𝑗(𝑘)$的值已经收敛，则算法结束，否则回到第2）步继续迭代。\n\n# 六、预测问题\n\n## 1、HMM最可能隐藏状态序列求解概述\n\n在HMM模型的解码问题中，给定模型$𝜆=(𝐴,𝐵,Π)$和观测序列$𝑂={𝑜_1,𝑜_2,...𝑜_𝑇}$，求给定观测序列O条件下，最可能出现的对应的状态序列$I^*= \\{i_1^*,i_2^*,...i_T^*\\}$,即$𝑃(𝐼^∗|𝑂)$要最大化 。\n \n一个可能的近似解法是求出观测序列𝑂在每个时刻𝑡最可能的隐藏状态$𝑖_𝑡^*$然后得到一个近似的隐藏状态序列$I^*= \\{i_1^*,i_2^*,...i_T^*\\}$。要这样近似求解不难，利用前向后向算法评估观察序列概率的定义：在给定模型𝜆和观测序列𝑂时，在时刻𝑡处于状态$𝑞_𝑖$的概率是$𝛾_𝑡(𝑖)$，这个概率可以通过HMM的前向算法与后向算法计算。这样我们有：\n\n$$i_t^* = arg \\max_{1 \\leq i \\leq N}[\\gamma_t(i)], \\; t =1,2,...T$$\n\n近似算法很简单，但是却不能保证预测的状态序列是整体是最可能的状态序列，因为预测的状态序列中某些相邻的隐藏状态可能存在转移概率为0的情况【也就是这样求解没有考虑到转移概率】。\n\n而维特比算法可以将HMM的状态序列作为一个整体来考虑，避免近似算法的问题【考虑转移概率】，下面我们来看看维特比算法进行HMM解码的方法。\n\n## 2、维特比算法概述\n\n维特比算法是一个通用的解码算法，是基于动态规划的求序列最短路径的方法。\n\n既然是动态规划算法，那么就需要找到合适的局部状态，以及局部状态的递推公式。在HMM中，维特比算法定义了两个局部状态用于递推。\n\n第一个局部状态是在时刻𝑡隐藏状态为𝑖所有可能的状态转移路径$i_1,i_2,...i_t$中的概率最大值。记为$𝛿_𝑡(𝑖)$:\n\n$$\\delta_t(i) = \\max_{i_1,i_2,...i_{t-1}}\\;P(i_t=i, i_1,i_2,...i_{t-1},o_t,o_{t-1},...o_1|\\lambda),\\; i =1,2,...N$$\n\n由$𝛿_𝑡(𝑖)$的定义可以得到𝛿的递推表达式：\n\n$$\n\\begin{align} \n\\delta_{t+1}(i) & = \\max_{i_1,i_2,...i_{t}}\\;P(i_{t+1}=i, i_1,i_2,...i_{t},o_{t+1},o_{t},...o_1|\\lambda) \\tag{1}\\\\ \n& = \\max_{1 \\leq j \\leq N}\\;[\\delta_t(j)a_{ji}]b_i(o_{t+1}) \\tag{2}\n\\end{align}\n$$\n\n第二个局部状态由第一个局部状态递推得到。我们定义在时刻𝑡隐藏状态为𝑖的所有单个状态转移路径$(i_1,i_2,...,i_{t-1},i)$中概率最大的转移路径中第𝑡−1个节点的隐藏状态为$Ψ_𝑡(𝑖)$,其递推表达式可以表示为：\n\n$$\\Psi_t(i) = arg \\; \\max_{1 \\leq j \\leq N}\\;[\\delta_{t-1}(j)a_{ji}]$$\n\n有了这两个局部状态，我们就可以从时刻0一直递推到时刻𝑇，然后利用Ψ𝑡(𝑖)记录的前一个最可能的状态节点回溯，直到找到最优的隐藏状态序列。\n\n## 3、维特比算法流程总结\n\n总结下维特比算法的流程：\n\n**输入：** HMM模型𝜆=(𝐴,𝐵,Π)，观测序列$O=(o_1,o_2,...o_T)$\n\n**输出：** 最有可能的隐藏状态序列$I^*= \\{i_1^*,i_2^*,...i_T^*\\}$\n\n1）初始化局部状态【时刻1的各个隐藏状态前向概率和上一个时刻的所有最可能的隐状态】：\n\n$$\\delta_1(i) = \\pi_ib_i(o_1),\\;i=1,2...N$$\n\n$$\\Psi_1(i)=0,\\;i=1,2...N$$\n\n2)进行动态规划递推时刻𝑡=2,3,...𝑇时刻的局部状态：\n\n$$\\delta_{t}(i) = \\max_{1 \\leq j \\leq N}\\;[\\delta_{t-1}(j)a_{ji}]b_i(0_{t}),\\;i=1,2...N$$\n\n$$\\Psi_t(i) = arg \\; \\max_{1 \\leq j \\leq N}\\;[\\delta_{t-1}(j)a_{ji}],\\;i=1,2...N$$\n\n3)计算时刻𝑇最大的$𝛿_𝑇(𝑖)$,即为最可能隐藏状态序列出现的概率。计算时刻𝑇最大的$Ψ_𝑡(𝑖)$,即为时刻𝑇最可能的隐藏状态。\n\n$$P* = \\max_{1 \\leq j \\leq N}\\delta_{T}(i)$$\n\n$$i_T^* = arg \\; \\max_{1 \\leq j \\leq N}\\;[\\delta_{T}(i)]$$\n\n4)利用局部状态Ψ(𝑖)开始回溯。对于𝑡=𝑇−1,𝑇−2,...,1：\n\n$$i_t^* = \\Psi_{t+1}(i_{t+1}^*)$$\n\n最终得到最有可能的隐藏状态序列$I^*= \\{i_1^*,i_2^*,...i_T^*\\}$\n\n## 4、HMM维特比算法求解实例\n\n我们的观察集合是:\n\n$$𝑉={红，白}，𝑀=2$$\n\n我们的状态集合是：\n\n$$𝑄=\\{盒子1，盒子2，盒子3\\}，𝑁=3$$\n\n而观察序列和状态序列的长度为3.\n\n初始状态分布为：\n\n$$\\Pi = (0.2,0.4,0.4)^T$$\n\n状态转移概率分布矩阵为：\n\n$$A = \\left( \\begin{array} {ccc} 0.5 & 0.2 & 0.3 \\\\ 0.3 & 0.5 & 0.2 \\\\ 0.2 & 0.3 &0.5 \\end{array} \\right)$$\n\n观测状态概率矩阵为：\n\n$$B = \\left( \\begin{array} {ccc} 0.5 & 0.5 \\\\ 0.4 & 0.6 \\\\ 0.7 & 0.3 \\end{array} \\right)$$\n\n球的颜色的观测序列:\n\n$$O=\\{红，白，红\\}$$\n\n首先计算时刻1三个状态的前向概率：\n\n\n\n首先需要得到三个隐藏状态在时刻1时对应的各自两个局部状态，此时观测状态为1：\n\n$$𝛿_1(1)=𝜋_1𝑏_1(𝑜_1)=0.2×0.5=0.1$$\n$$𝛿_1(2)=𝜋_2𝑏_2(𝑜_1)=0.4×0.4=0.16$$\n$$𝛿_1(3)=𝜋_3𝑏_3(𝑜_1)=0.4×0.7=0.28$$\n$$Ψ_1(1)=Ψ_1(2)=Ψ_1(3)=0$$\n\n现在开始递推三个隐藏状态在时刻2时对应的各自两个局部状态，此时观测状态为2：\n\n$$\\delta_2(1) = \\max_{1\\leq j \\leq 3}[\\delta_1(j)a_{j1}]b_1(o_2) = \\max_{1\\leq j \\leq 3}[0.1 \\times 0.5, 0.16 \\times 0.3, 0.28\\times 0.2] \\times 0.5 = 0.028$$\n\n$$\\Psi_2(1)=3$$\n\n$$\\delta_2(2) = \\max_{1\\leq j \\leq 3}[\\delta_1(j)a_{j2}]b_2(o_2) = \\max_{1\\leq j \\leq 3}[0.1 \\times 0.2, 0.16 \\times 0.5, 0.28\\times 0.3] \\times 0.6 = 0.0504$$\n\n$$\\Psi_2(2)=2$$\n\n$$\\delta_2(3) = \\max_{1\\leq j \\leq 3}[\\delta_1(j)a_{j3}]b_3(o_2) = \\max_{1\\leq j \\leq 3}[0.1 \\times 0.3, 0.16 \\times 0.2, 0.28\\times 0.5] \\times 0.3 = 0.042$$\n\n$$\\Psi_2(3)=3$$\n\n继续递推三个隐藏状态在时刻3时对应的各自两个局部状态，此时观测状态为1：\n\n$$\\delta_3(1) = \\max_{1\\leq j \\leq 3}[\\delta_2(j)a_{j1}]b_1(o_3) = \\max_{1\\leq j \\leq 3}[0.028 \\times 0.5, 0.0504 \\times 0.3, 0.042\\times 0.2] \\times 0.5 = 0.00756$$\n\n$$\\Psi_3(1)=2$$\n\n$$\\delta_3(2) = \\max_{1\\leq j \\leq 3}[\\delta_2(j)a_{j2}]b_2(o_3) = \\max_{1\\leq j \\leq 3}[0.028 \\times 0.2, 0.0504\\times 0.5, 0.042\\times 0.3] \\times 0.4 = 0.01008$$\n\n$$\\Psi_3(2)=2$$\n\n$$\\delta_3(3) = \\max_{1\\leq j \\leq 3}[\\delta_2(j)a_{j3}]b_3(o_3) = \\max_{1\\leq j \\leq 3}[0.028 \\times 0.3, 0.0504 \\times 0.2, 0.042\\times 0.5] \\times 0.7 = 0.0147$$\n\n$$\\Psi_3(3)=3$$\n\n此时已经到最后的时刻，我们开始准备回溯。此时最大概率为$𝛿_3(3)$,从而得到$𝑖_3^*=3$\n\n由于$Ψ_3(3)=3$,所以$𝑖_2^*=3$, 而又由于$Ψ_2(3)=3$,所以$𝑖_1^*=3$。从而得到最终的最可能的隐藏状态序列为：$(3,3,3)$\n\n## 5、HMM模型维特比算法总结\n\n维特比算法也是寻找序列最短路径的一个通用方法，和dijkstra算法有些类似，但是dijkstra算法并没有使用动态规划，而是贪心算法。同时维特比算法仅仅局限于求序列最短路径，而dijkstra算法是通用的求最短路径的方法。\n\n\n```python\n\n```\n", "meta": {"hexsha": "f73123c0c11222990fefa056646b367eab7c2443", "size": 30991, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "algorithm/hmm/hmm.ipynb", "max_stars_repo_name": "v-smwang/AI-NLP-Tutorial", "max_stars_repo_head_hexsha": "3dbfdc7e19a025e00febab97f4948da8a3710f34", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "algorithm/hmm/hmm.ipynb", "max_issues_repo_name": "v-smwang/AI-NLP-Tutorial", "max_issues_repo_head_hexsha": "3dbfdc7e19a025e00febab97f4948da8a3710f34", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "algorithm/hmm/hmm.ipynb", "max_forks_repo_name": "v-smwang/AI-NLP-Tutorial", "max_forks_repo_head_hexsha": "3dbfdc7e19a025e00febab97f4948da8a3710f34", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.793902439, "max_line_length": 389, "alphanum_fraction": 0.521603046, "converted": true, "num_tokens": 16450, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41869692386284973, "lm_q2_score": 0.27202455699569283, "lm_q1q2_score": 0.11389584522925103}}
{"text": "```python\nimport numpy as np\n%load_ext autoreload\n```\n\nNotebook by **Maxime Dion** \n\n\n\nDone this way the parametrized circuit can be drawn right away.\n\n\n```python\nvarform_qc.draw('mpl')\n```\n\nTo see what are the parameters of a parametrized `QuantumCircuit` you can use\n\n\n```python\nvarform_qc.parameters\n```\n\n\n\n\n {Parameter(a), Parameter(b)}\n\n\n\n**Important** Beware that sometimes the parameters will not appear in the same order as you declared them!\n\nTo assign values to the different parameters we need to use the `QuantumCircuit.assign_paremeters()` method. This methods takes a `dict` as an argument containing the `Parameter`s and their `value`s.\n\n\n```python\nparam_dict = {a : 1, b : 2}\nqc = varform_qc.assign_parameters(param_dict)\nqc.draw('mpl')\n```\n\n\n```python\nparam_dict = {a : 3, b : 4}\nqc = varform_qc.assign_parameters(param_dict)\nqc.draw('mpl')\n```\n\nIf you want to provide the parameter values as a `list` or a `np.array` you can build the `dict` directly. Just make sure that the order you use in `param_values` corresponds to the other of `varform_qc.parameters`.\n\n\n```python\nparam_values = [1, 2]\nparam_dict = dict(zip(varform_qc.parameters,param_values))\nprint(param_dict)\n```\n\n {Parameter(a): 1, Parameter(b): 2}\n\n\n## Varforms circuits for H2\nUsing the method of your choice, prepare 2 different 4-qubit `QuantumCircuit`s. \n- The first should take 1 parameter to cover the real coefficients state sub space spanned by $|0101\\rangle$ and $|1010\\rangle$.\n- The second should take 3 parameters to cover the real coefficients state sub space spanned by $|0101\\rangle$, $|0110\\rangle$, $|1001\\rangle$ and $|1010\\rangle$.\n\nRevisit the presentation to find such circuits.\n\n\n```python\nvarform_4qubits_1param = QuantumCircuit(4)\na = Parameter('a')\n\"\"\"\nYour code here\n\"\"\"\nvarform_4qubits_1param.ry(a,1)\nvarform_4qubits_1param.x(0)\nvarform_4qubits_1param.cx(1,0)\nvarform_4qubits_1param.cx(0,2)\nvarform_4qubits_1param.cx(1,3)\n\nvarform_4qubits_1param.draw('mpl')\n```\n\n\n```python\nvarform_4qubits_3params = QuantumCircuit(4)\na = Parameter('a')\nb = Parameter('b')\nc = Parameter('c')\n\"\"\"\nYour code here\n\"\"\"\nvarform_4qubits_3params.x(0)\nvarform_4qubits_3params.x(2)\nvarform_4qubits_3params.barrier(range(4))\nvarform_4qubits_3params.ry(a,1)\nvarform_4qubits_3params.cx(1,3)\nvarform_4qubits_3params.ry(b,1)\nvarform_4qubits_3params.ry(c,3)\nvarform_4qubits_3params.cx(3,2)\nvarform_4qubits_3params.cx(1,0)\n\nvarform_4qubits_3params.draw('mpl')\n```\n\n# Evaluator\nThe `Evaluator` is an object that will help us to evaluate the expectation value of a quantum operator (`LCPS`) on a specific variational form and backend. To initialize and `Evaluator` you should provide :\n\n**Mandatory**\n- A **variational form** that can create a `QuantumCircuit` given a set of `params`;\n- A **backend** `qiskit.Backend` (a simulator or an actual device handle) on which to run the `QuantumCircuit`\n\n**Optional**\n- `execute_opt` is a `dict` containing the optionnal argument to pass to the `qiskit.execute` method (ex : `{'shots' : 1024}`.\n- `measure_filter` a `qiskit.ignis...MeasurementFilter` that can be applied to the result of a circuit executation to mitigate readout errors.\n\nThe creation/usage of an `Evaluator` such as `BasicEvaluator` goes like this :\n\n\nevaluator = BasicEvaluator(varform_qc,backend)\n\nFirst you initialize the evaluator.\n\nNext, you provide the operator you want to evaluate using the `set_linear_combinaison_pauli_string(LCPS)` method. \n\nFinally, you call the `eval(params)` method that will return the estimation of the operator's expected value. Mathematicaly, the use of this method corresponds to \n\n\\begin{align}\nE(\\boldsymbol{\\theta}).\n\\end{align}\n\nWe will now go through the different pieces neccessary to complete the `Evaluator` class.\n\n## Static methods\nBeing static, these method do not need an instance of a class to be used. They can be called directly from the class.\n\nThese methods are called before the first call to `eval(params)`. Most of these methods are implemented inside the abstract class `Evaluator` (except for `prepare_measurement_circuits_and_interpreters(LCPS)`)\n\n### Pauli Based Measurements\nWe have seen that even if a quantum computer can only measure qubits in the Z-basis, the X and Y-basis are accessible if we *rotate* the quantum state before measuring. \n\nImplement the `@staticmethod` : `pauli_string_based_measurement(PauliString)` in the `Evaluator` class in file `Evaluator.py` that returns a `QuantumCircuit` that measures each qubit in the basis given by the `PauliString`.\n\nFirst we import the abstract class `Evaluator` and the `PauliString` class.\n\n\n```python\nfrom evaluator import Evaluator\nfrom pauli_string import PauliString\n```\n\nTest your code with the next cell.\n\n\n```python\n%autoreload\npauli_string = PauliString.from_str('ZIXY')\nmeasure_qc = Evaluator.pauli_string_based_measurement(pauli_string)\nmeasure_qc.draw('mpl')\n```\n\n### Measurable eigenvalues\n\nImplement the `@staticmethod` : `measurable_eigenvalues(PauliString)` in the `Evaluator` class in file `Evaluator.py` that returns a `np.array` that contains the eigenvalues of the measurable `PauliString` for each basis state. We noted this vector\n\n\\begin{align}\n \\Lambda_q^{\\hat{(\\mathcal{P})}}.\n\\end{align}\n\nBe mindful of the order of the basis state.\n\n\\begin{align}\n 0000, 0001, 0010, \\ldots, 1110, 1111 \n\\end{align}\n\nYou can test your implementation on the `ZIXY` Pauli string.\n\n\n```python\n%autoreload\npauli_string = PauliString.from_str('ZIXY')\nmeasurable_eigenvalues = Evaluator.measurable_eigenvalues(pauli_string)\nprint(measurable_eigenvalues)\n```\n\n [ 1 -1 -1 1 1 -1 -1 1 -1 1 1 -1 -1 1 1 -1]\n\n\nFor the `PauliString` `'ZIXY'` (measurable `'ZIZZ'`) you should get the following eigenvalues :\n\n\n[ 1 -1 -1 1 1 -1 -1 1 -1 1 1 -1 -1 1 1 -1]\n\n\n### Measurement Circuits and Interpreters\nThe `prepare_measurement_circuits_and_interpreters(LCPS)` is specific to the sub-type of `Evaluator`. The two different types of `Evaluator`s considered in this workshop are :\n- The `BasicEvaluator` will run a single `QuantumCircuit` for each `PauliString` present in the provided `LCPS`.\n- The `BitwiseCommutingCliqueEvaluator` will exploit Bitwise Commuting Clique to combine the evaluation of Commuting `PauliStrin`s and reduce the number of different `QuantumCircuit` run for each evaluation. \n\nImplement the `prepare_measurement_circuits_and_interpreters(LCPS)` method in the `BasicEvaluator` class in file `Evaluator.py`. This method should return 2 `list`. The first should contain one measurement `QuantumCircuit` for each `PauliString` in the `LCPS`. The second list should contain one `np.array` of the eigenvalues of the measurable `PauliString` for each basis state.\n\n**Note** You can try to implement similar methods for the `BitwiseCommutingCliqueEvaluator`.\n\nYou can test your method on `2 ZIXY + 1 IXYZ`.\n\n\n```python\nfrom evaluator import BasicEvaluator\n```\n\n\n```python\n%autoreload\nlcps = 2*PauliString.from_str('ZIXY') + 1*PauliString.from_str('IXYZ')\nmeasurement_circuits, interpreters = BasicEvaluator.prepare_measurement_circuits_and_interpreters(lcps)\n```\n\nYou can visualize the interpreter and the measurement circuit for each term in the `LCPS` by using `i = 0` and `i = 1`.\n\n\n```python\ni = 1\nprint(interpreters[i])\nmeasurement_circuits[i].draw('mpl')\n```\n\nThe interpreters should be respectively :\n\n\n[ 2 -2 -2 2 2 -2 -2 2 -2 2 2 -2 -2 2 2 -2]\n\n### Set the LCPS\nThe method `set_linear_combinaison_pauli_string(LCPS)` is already implemented inside the abstract class `Evaluator`. Please take a look at it to notice that this method makes an immediate call to the `prepare_measurement_circuits_and_interpreters(LCPS)` method you have just implemented. The `measurement_circuits` and `interpreters` are also stored in attributes of the same name.\n\n## Methods called inside `eval(params)`\nSince we are entering the action of the `eval(params)` method we will need to instantiate an `Evaluator`. This will require a `backend`. We will use a local `qasm_simulator` for now, which is part of the `Aer` module. In the future, you can use a different `backend`. We will also soon need the `execute` method.\n\n\n```python\nfrom qiskit import Aer, execute\nqasm_simulator = Aer.get_backend('qasm_simulator')\n```\n\n### Circuit preparation\nThe `prepare_eval_circuits(params)` will combine the variational form with these measurement `QuantumCircuit`s to form the complete circuit to be run. This method has 2 tasks :\n- Assign the `params` to the variationnal form to get a `QuantumCircuit` that prepares the quantum state\n- Combine this circuit with all the measurement circuits to return as many `QuantumCircuit` inside a `list`.\n\nImplement this method inside the `Evaluator` class and test it here.\n\n\n```python\n%autoreload\nlcps = 2*PauliString.from_str('ZXZX') + 1*PauliString.from_str('IIZZ')\nvarform = varform_4qubits_1param\nbackend = qasm_simulator\nevaluator = BasicEvaluator(varform,backend)\nevaluator.set_linear_combinaison_pauli_string(lcps)\nparams = [0,]\neval_circuits = evaluator.prepare_eval_circuits(params)\n```\n\nYou can take a look at the `QuantumCircuit` for the first (`i=0`) and second (`i=1`) PauliString. What you should get is a circuit that begins with the state preparation circuit with the `params` applied to it followed by the measurement circuit.\n\n\n```python\ni = 0\neval_circuits[i].draw('mpl')\n```\n\n### Execution\nThe ultimate goal to the execution of a circuit is to get the number of times each basis state is measured. Let's execute our `eval_circuits`. We can run many `QuantumCircuit`s at the same time by placing them into a `list`, which they already are!\n\n\n```python\nexecute_opts = {'shots' : 1024}\njob = execute(eval_circuits, backend=qasm_simulator, **execute_opts)\nresult = job.result()\n```\n\nWe can get the number of counts of each state for the execution of a given circuit with the follow lines. The counts are returned as a `dict`.\n\n\n```python\ni = 0\n#i = 1\ncounts = result.get_counts(eval_circuits[i])\nprint(counts)\n```\n\n {'0000': 266, '0001': 251, '0100': 262, '0101': 245}\n\n\nIf you `eval_circuits` are correct, you should get for, `i = 0` and `i = 1` respectively, something like this (exact value may vary since there is some randomness in the executation of a quantum circuit)\n\n\n{'0000': 266, '0001': 262, '0100': 240, '0101': 256}\n\n### counts2array\n\nWe will transform this `dict` into an array with the `counts2array` method. Implement this method that will return the vector $N_q$. Be mindful of the order of the basis state.\n\n\\begin{align}\n 0000, 0001, 0010, \\ldots, 1110, 1111 \n\\end{align}\n\n**optional remark** While doing this will allow us to interpret the counts with a simple inner product, this implies creating an array of size $2^n$ where $n$ is the numbers of qubits. This might not be such a good idea for larger systems and the use of a `dict` might be more appropriate. Can you interpret the counts efficiently while keeping them in a `dict`?\n\n\n```python\n%autoreload\ni = 0\ncounts = result.get_counts(eval_circuits[i])\nevaluator.counts2array(counts)\n```\n\n\n\n\n array([266, 251, 0, 0, 262, 245, 0, 0, 0, 0, 0, 0, 0,\n 0, 0, 0])\n\n\n\nFor `i=0` in particular you should get something similar to:\n\n\narray([228., 276., 0., 0., 269., 251., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])\n\n\n### Interpret counts\nThe action of interpreting the counts is actually the task of estimating the expectation value of a `PauliString` and multiplying by the coefficient associated with this `PauliString` in the LCPS. Implemented the `interpret_count_array` method that should return an array with the values for this expression.\n\n\\begin{align}\n h_i \\langle \\hat{\\mathcal{P}}_i \\rangle = \\frac{h_i}{N_\\text{tot}}\\sum_{q} N_q \\Lambda_q^{(\\hat{\\mathcal{P}}_i)}\n\\end{align}\n\n\n```python\n%autoreload\ni = 1\ncounts_array = evaluator.counts2array(result.get_counts(eval_circuits[i]))\ninterpreter = evaluator.interpreters[i]\nexpected_value = evaluator.interpret_count_array(interpreter,counts_array)\nprint(expected_value)\n```\n\n (-1+0j)\n\n\nYou should get something close to `0` for the first one and `-1` for the second.\n\n### Evaluation\nYou have now all the pieces to complete the `eval(params)` method. This method should use all the methods you've implemented since the section *Methods called inside `eval(params)`* and then sum all the interpreted values. Mathematicaly, it should return the value of the expression\n\n\\begin{align}\n E(\\boldsymbol{\\theta}) = \\sum_i h_i \\langle\\psi(\\boldsymbol{\\theta}) | \\hat{\\mathcal{P}}_i | \\psi(\\boldsymbol{\\theta}) \\rangle.\n\\end{align}\n\n\n```python\n%autoreload\nlcps = 2*PauliString.from_str('ZXZX') + 1*PauliString.from_str('IIZZ')\nvarform = varform_4qubits_1param\nbackend = qasm_simulator\nexecute_opts = {'shots' : 1024}\nevaluator = BasicEvaluator(varform, backend, execute_opts=execute_opts)\nevaluator.set_linear_combinaison_pauli_string(lcps)\nparams = [0,]\nexpected_value = evaluator.eval(params)\nprint(expected_value)\n```\n\n -1.0703125\n\n\nYes that's right, your code now returns an estimate of the expression\n\n\\begin{align}\n E(\\theta) = \\langle \\psi(\\theta) | \\hat{\\mathcal{H}} | \\psi(\\theta) \\rangle.\n\\end{align} \n\nfor\n\n\\begin{align}\n \\hat{\\mathcal{H}} = 2\\times \\hat{Z}\\hat{X}\\hat{Z}\\hat{X} + 1\\times \\hat{I}\\hat{I}\\hat{Z}\\hat{Z}\n\\end{align} \n\nand the varform `varform_4qubits_1param` for $\\theta = 0$. The `evaluator.eval(params)` is now a method you can call like a function and it will return the energy $E(\\theta)$.\n\nNow comes the time to test this on the $\\text{H}_2$ molecule Hamiltonian!\n\n## The Hamiltonian evaluation test\n\nWe will now import the classes from the previous activity.\n\n\n```python\nfrom hamiltonian import MolecularFermionicHamiltonian\nfrom mapping import JordanWigner\n```\n\nFor ease of use we will import the integral values instead of using `pyscf`. We also import the Coulomb repulsion energy for later use. By now we are experts in building the Hamiltonian.\n\n\n```python\nwith open('Integrals_sto-3g_H2_d_0.7350_no_spin.npz','rb') as f:\n out = np.load(f)\n h1_load_no_spin = out['h1']\n h2_load_no_spin = out['h2']\n energy_nuc = out['energy_nuc']\n \nmolecular_hamiltonian = MolecularFermionicHamiltonian.from_integrals(h1_load_no_spin,h2_load_no_spin).include_spin()\n```\n\nWe use the Jordan-Wigner mapping to the get the `LCPS` for the H2 molecule with `d=0.735`. \n\n\n```python\n%autoreload\nmapping = JordanWigner()\n\nlcps_h2 = mapping.fermionic_hamiltonian_to_linear_combinaison_pauli_string(molecular_hamiltonian).combine().apply_threshold().sort()\nprint(lcps_h2)\n```\n\n 15 pauli strings for 4 qubits (Real, Imaginary)\n IIII (-0.81055,+0.00000)\n IIIZ (+0.17218,+0.00000)\n IIZI (-0.22575,+0.00000)\n IIZZ (+0.12091,+0.00000)\n IZII (+0.17218,+0.00000)\n IZIZ (+0.16893,+0.00000)\n IZZI (+0.16615,+0.00000)\n ZIII (-0.22575,+0.00000)\n ZIIZ (+0.16615,+0.00000)\n ZIZI (+0.17464,+0.00000)\n ZZII (+0.12091,+0.00000)\n XXXX (+0.04523,+0.00000)\n XXYY (+0.04523,+0.00000)\n YYXX (+0.04523,+0.00000)\n YYYY (+0.04523,+0.00000)\n\n\nWe build an evaluator and feed it the `LCPS` of H2. And them we evaluate the energy. Use `params` in order that your `varform` prepares the state $|0101\\rangle$.\n\n\n```python\n%autoreload\nvarform = varform_4qubits_1param\nbackend = qasm_simulator\nexecute_opts = {'shots' : 1024}\nevaluator = BasicEvaluator(varform,backend,execute_opts = execute_opts)\nevaluator.set_linear_combinaison_pauli_string(lcps_h2)\nparams = [0,]\nexpected_value = evaluator.eval(params)\nprint(expected_value)\n```\n\n -1.8370563365153778\n\n\nIf your `varform` prepares the state $|0101\\rangle$, you should get something around `-1.83`. This energy is already close to the ground state energy because the ground state is close to $|0101\\rangle$, but still it's not the ground state. We need to find the `params` that will minimise the energy.\n\n\\begin{align}\n E_0 = \\min_{\\boldsymbol{\\theta}} E(\\boldsymbol{\\theta})\n\\end{align}\n\n# Solver\n\nIn a final step we need to implement a solver that will try to find the minimal energy. We will implement 2 solvers. The second is optional.\n- First the one using the VQE algo in conjunction with a minimizer to try to minimize `evaluator.eval(params)`.\n- Next we will make use of the `to_matrix()` method you implemented in the previous activity to find the exact value/solution.\n\n## VQE Solver\n\nLike any minimzation process this solver will need a couple of ingredients :\n- A function to minimize, we will provide this with the evaluator\n- A minimizer, an algorithm that generaly takes in a function and a set of starting parameters and returns the best guess for the optimal parameters that correspond to the minimal value of the function to minimize.\n- A set of starting parameters.\n\n### Minimizer\n\nA minimizer that works OK for the VQE algorithme is the Sequential Least SQuares Programming (SLSQP) algorithm. It's available in the `minimize` sub-module of [scipy](https://docs.scipy.org/doc/scipy/reference/optimize.minimize-slsqp.html).\n\n\n```python\nfrom scipy.optimize import minimize\n```\n\nWe will make a Lambda function with the minimizer so we can set all sorts of parameter before feeding it to the solver.\n\n\n```python\nminimizer = lambda fct, start_param_values : minimize(\n fct,\n start_param_values,\n method = 'SLSQP', \n options = {'maxiter' : 5,'eps' : 1e-1, 'ftol' : 1e-4, 'disp' : True, 'iprint' : 2})\n```\n\nThe `minimizer` now takes only 2 arguments : the function and the starting parameters values. We also specify some options :\n- A small value for the maximum number of iteration. You will find that running the VQE algorithm is expensive because of the `evaluator.eval(params)` method. Either it's long to simulate on `qasm_simulator` or because it's running on an actual quantum computer.\n- A `eps` of `0.1`. This is the size of the step the algorithm is going to change the values of the parameters to try to estimate the slope of the function. By the way, a lot of minimizing algorithms use the slope of the function to know in which direction is the minimum. Since our parameters are all angles in radians a value of 0.1 seems reasonnable. Play with this value if you like.\n- A `ftol` value of `1e-4`. This is the goal for the precision of the value of the minimum value. The chemical accuracy is around 1 milli-Hartree.\n- We set `iprint` to `2` so see what is going on. For your final implementation you can set this to `0`.\n\nBefore implementing the `VQESolver` let's try this minimizer! The function is `evaluator.eval` and we start with a parameter of `0`. This will take a while.\n\n\n```python\nminimization_result = minimizer(evaluator.eval,[0,])\n```\n\n NIT FC OBJFUN GNORM\n 1 3 -1.834406E+00 2.276211E-01\n 2 6 -1.857755E+00 4.369813E-02\n 3 11 -1.860118E+00 1.790857E-02\n Optimization terminated successfully. (Exit mode 0)\n Current function value: -1.8601177724457674\n Iterations: 3\n Function evaluations: 11\n Gradient evaluations: 3\n\n\nIn the end you should get an minimal energy around `1.86` Hartree. Which is a bit smaller then what we had before minimizing. You can explore the `minimization_result` to retreive this value but also the set of optimal parameters.\n\n\n```python\nopt_params = minimization_result.x\nopt_value = minimization_result.fun\nprint(opt_params)\nprint(opt_value)\n```\n\n [-0.22882531]\n -1.8601177724457674\n\n\n### VQE Solver\n\nNow you should be in good position to implement the `lowest_eig_value(lcps)` of the `VQESolver` class inside the `Solve.py` file. Test your method here.\n\n\n```python\nfrom solver import VQESolver\n```\n\n\n```python\n%autoreload\nvqe_solver = VQESolver(evaluator, minimizer, [0,], name = 'vqe_solver')\nopt_value, opt_params = vqe_solver.lowest_eig_value(lcps_h2)\n```\n\n NIT FC OBJFUN GNORM\n 1 3 -1.839000E+00 2.553151E-01\n 2 6 -1.865535E+00 6.395731E-02\n Optimization terminated successfully. (Exit mode 0)\n Current function value: -1.865591974724343\n Iterations: 2\n Function evaluations: 10\n Gradient evaluations: 2\n\n\nThe is only one thing missing to have the complete molecular energy : the Coulomb repulsion energy from the nucleus. This value was loaded when we imported the integrals. Let's add it to the electronic energy.\n\n\n```python\nprint('Ground state position estimate (vqe) : ', opt_params)\nprint('Ground state energy estimate (electronic, vqe) : ', opt_value)\nprint('Ground state energy estimate (molecular, vqe) : ', opt_value + energy_nuc)\n```\n\n Ground state position estimate (vqe) : [-0.25526396]\n Ground state energy estimate (electronic, vqe) : -1.865591974724343\n Ground state energy estimate (molecular, vqe) : -1.1456229802753635\n\n\n### The Eigenstate\n\nWhat is the eigenstate? We can partially find out by using the `varform` with the parameters we have found and measure everything in the Z basis.\n\n\n```python\neigenstate_qc = varform.copy()\neigenstate_qc.measure_all()\n\nparam_dict = dict(zip(eigenstate_qc.parameters,opt_params))\neigenstate_qc = eigenstate_qc.assign_parameters(param_dict)\n\neigenstate_qc.draw('mpl')\n```\n\nWe now execute this circuit.\n\n\n```python\nexecute_opts = {'shots' : 1024}\njob = execute(eigenstate_qc,backend=qasm_simulator,**execute_opts)\nresult = job.result()\ncounts = result.get_counts(eigenstate_qc)\n```\n\nWe will use the `plot_histogram` method from `qiskit.visualization` that takes the counts `dict` as an input. \n\n\n```python\nfrom qiskit.visualization import plot_histogram\n```\n\n\n```python\nplot_histogram(counts)\n```\n\n\n```python\nprint(f\"|a_0101| ~ {np.sqrt(counts['0101']/1024)}\")\nprint(f\"|a_1010| ~ {np.sqrt(counts['1010']/1024)}\")\n```\n\n |a_0101| ~ 0.9936320684740404\n |a_1010| ~ 0.11267347735824966\n\n\nWe see that the found solution is mostly the state $|0101\\rangle$ which is the Hartree-Fock solution when the 2-body Hamiltonian is not present. Adding this 2-body physics, shifts the energy down a bit by introducing a small contribution of $|1010\\rangle$. The actual statevector has a `-` sign between these two states.\n\n\\begin{align}\n\\alpha_{0101}|0101\\rangle - \\alpha_{1010}|1010\\rangle\n\\end{align}\n\nBut this is not something we can know from this. Fortunatly, H2 is a small system which can be solved exactly and we can find out this phase.\n\n## Exact Solver (optional)\n\nIf you want to compare the value you get with the VQE algorithm it would be nice to have the exact value. If you were able to implement the `to_matrix()` method for `PauliString` and `LinearCombinaisonPauliString` then you can find the exact value of the ground state. All you need is to diagonalise the matrix reprensenting the whole Hamiltonian and find the lowest eigenvalue! Obviously this will not be possible to do for very large systems.\n\n\n```python\nhamiltonian_matrix_h2 = lcps_h2.to_matrix()\neig_values, eig_vectors = np.linalg.eigh(hamiltonian_matrix_h2)\neig_order = np.argsort(eig_values)\neig_values = eig_values[eig_order]\neig_vectors = eig_vectors[:,eig_order]\nground_state_value, ground_state_vector = eig_values[0], eig_vectors[:,0]\nprint('Ground state vector (exact) : \\n', ground_state_vector)\nprint('Ground state energy (electronic, exact) : ', ground_state_value)\nprint('Ground state energy (molecular, exact) : ', ground_state_value + energy_nuc)\n```\n\n Ground state vector (exact) : \n [-0. -0.j -0. -0.j -0. -0.j -0. -0.j\n -0. -0.j -0.9937604 -0.j 0. +0.j 0. +0.j\n 0. +0.j 0. +0.j 0.11153594+0.j 0. +0.j\n 0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n Ground state energy (electronic, exact) : -1.8572750302023788\n Ground state energy (molecular, exact) : -1.137306035753399\n\n\nNow you can complete the `ExactSolver` in the `Solver.py` file.\n\n\n```python\nfrom solver import ExactSolver\n```\n\n\n```python\n%autoreload\nexact_solver = ExactSolver()\nground_state_value, ground_state_vector = exact_solver.lowest_eig_value(lcps_h2)\nprint('Ground state vector (exact) : ', ground_state_vector)\nprint('Ground state energy (electronic, exact) : ', ground_state_value)\nprint('Ground state energy (molecular, exact) : ', ground_state_value + energy_nuc)\n```\n\n Ground state vector (exact) : [-0. -0.j -0. -0.j -0. -0.j -0. -0.j\n -0. -0.j -0.9937604 -0.j 0. +0.j 0. +0.j\n 0. +0.j 0. +0.j 0.11153594+0.j 0. +0.j\n 0. +0.j 0. +0.j 0. +0.j 0. +0.j]\n Ground state energy (electronic, exact) : -1.8572750302023788\n Ground state energy (molecular, exact) : -1.137306035753399\n\n\nWhat are the two basis state involved in the ground state? Let's plot the state vector using `matplotlib`.\n\n\n```python\nimport matplotlib.pyplot as plt\n```\n\n\n```python\nfig,ax = plt.subplots(1,1)\ni_max = np.argmax(np.abs(ground_state_vector))\nstate = ground_state_vector * np.sign(ground_state_vector[i_max])\nax.bar(range(len(state)), np.abs(state), color=(np.real(state) > 0).choose(['r','b']))\nplt.xticks(range(len(state)),[f\"{i:04b}\" for i in range(len(state))], size='small',rotation=60);\n```\n\n# What's next?\n\nNow that you can find the ground state for a specific H2 molecule configuration (`d = 0.735`), you should be able to do that for many configurations, say `d = 0.2` to `2.5`. Doing that will enable you to plot the so-called dissociation curve : energy vs distance. Do not forget to include the Coulomb repulsion energy of the nucleus!\n\nYou could also run your algorithm on a noisy backend, either a noisy simulator or a real quantum computer. You've already seen on day 1 how to set/get a noisy backend. You'll see that noise messes things up pretty bad.\n\nRunning on real machine will introduce the problem of the qubit layout. You might want to change the `initial_layout` in the `execute_opts` so that your `varform` is not applying CNOT gates between qubits that are not connected. You know this needs to insert SWAP gate and this introduce more noise. Also covered in day 1.\n\nTo limit the effect of readout noise, you could add a `measure_filter` to your `evaluator`, so that each time you execute the `eval_circuits` you apply the filter to the results. Also covered in day 1.\n\nImplement the simulatneous evaluation for bitwise commuting cliques or even for general commuting cliques.\n\nNotebook by **Maxime Dion** here .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n```\n\n\n\nToggle cell visibility here .\n\n\n## Regulator Design: observer and state feedback\n\nThis example demonstrates the design of a regulator: a type of controller composed by an observer and a full-state feedback controller. It can be proven that, thanks to the separation principle, the controller and the observer can be designed independently - closed-loop eigenvalues and observer dynamics can be set separately without affecting each other.\n\nNonetheless, closed-loop transient performance depends on how fast the observer is with respect to the desired closed-loop dynamics. \n\nThis example shows the design of a regulator for the controllable and observable system:\n\n\\begin{cases}\n\\dot{\\textbf{x}}=\\begin{bmatrix}1&0&3\\\\0&-4&-1\\\\0&1&-4\\end{bmatrix}\\textbf{x}+\\begin{bmatrix}0\\\\0\\\\1\\end{bmatrix}\\textbf{u} \\\\ \\\\\n\\textbf{y}=\\begin{bmatrix}1&0&0\\end{bmatrix}\\textbf{x}\n\\end{cases}\n\nthat has the transfer function:\n\n$$\nG(s) = C(sI-A)^{-1}B.\n$$\n\n### Development of the state feedback\nThe goal is to place 3 eigenvalues in $-1$ rad/s or faster in order to have a good transient response. A possible solution is: $K = \\begin{bmatrix}\\frac{8}{15}&-4.4&-4\\end{bmatrix}$.\n\n\n### Development of the observer\nGiven the eigenvalues of the controlled system, a better (faster and stable) choice for the observer is $\\lambda_{1,2,3} = -10$ rad/s. This can be achieved with $L=\\begin{bmatrix}23&66&\\frac{107}{3}\\end{bmatrix}^T$.\n\n\n### Composition of the regulator\n\nThe regulator can be implemented in two ways, as a transfer function:\n\n\n\nwhere:\n\n$$\nK(s) = -K(sI-A+LC+BK)^{-1}L\\,.\n$$\n\nor as an observer with static feedback:\n\n\n\nRecall that although the obtained closed dynamics is the same, the transfer function implementation may lead to an unstable controller - the eigenvalues of matrix (matrix $A-BK-LC$) may be unstable even if closed-loop dynamics is stable. \n\n### How to use this notebook?\n- Try to change the initial conditions of the estimator (default is $\\begin{bmatrix}0.2&0.2&0.2\\end{bmatrix}^T$) and the observer's eigenvalues and see how the controlled system behaviour changes.\n- Try to change the values in order to achieve settling time for 5% tolerance band of less than 2 s.\n\n**Note:** \n\n- The ideal values refer to the case in which all the states of the system can be measured.\n- The **Inverse reference gain** slider denotes the value for which the reference is divided (as you change the static gain of the closed-loop transfer function); in order to reach zero error for the step response its value is equal to the static gain.\n\n\n```python\n%matplotlib inline\nimport control as control\nimport numpy\nimport sympy as sym\nfrom IPython.display import display, Markdown\nimport ipywidgets as widgets\nimport matplotlib.pyplot as plt\n\n\n#print a matrix latex-like\ndef bmatrix(a):\n \"\"\"Returns a LaTeX bmatrix - by Damir Arbula (ICCT project)\n\n :a: numpy array\n :returns: LaTeX bmatrix as a string\n \"\"\"\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{bmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{bmatrix}']\n return '\\n'.join(rv)\n\n\n# Display formatted matrix: \ndef vmatrix(a):\n if len(a.shape) > 2:\n raise ValueError('bmatrix can at most display two dimensions')\n lines = str(a).replace('[', '').replace(']', '').splitlines()\n rv = [r'\\begin{vmatrix}']\n rv += [' ' + ' & '.join(l.split()) + r'\\\\' for l in lines]\n rv += [r'\\end{vmatrix}']\n return '\\n'.join(rv)\n\n\n#matrixWidget is a matrix looking widget built with a VBox of HBox(es) that returns a numPy array as value !\nclass matrixWidget(widgets.VBox):\n def updateM(self,change):\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.M_[irow,icol] = self.children[irow].children[icol].value\n #print(self.M_[irow,icol])\n self.value = self.M_\n\n def dummychangecallback(self,change):\n pass\n \n \n def __init__(self,n,m):\n self.n = n\n self.m = m\n self.M_ = numpy.matrix(numpy.zeros((self.n,self.m)))\n self.value = self.M_\n widgets.VBox.__init__(self,\n children = [\n widgets.HBox(children = \n [widgets.FloatText(value=0.0, layout=widgets.Layout(width='90px')) for i in range(m)]\n ) \n for j in range(n)\n ])\n \n #fill in widgets and tell interact to call updateM each time a children changes value\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n self.children[irow].children[icol].observe(self.updateM, names='value')\n #value = Unicode('example@example.com', help=\"The email value.\").tag(sync=True)\n self.observe(self.updateM, names='value', type= 'All')\n \n def setM(self, newM):\n #disable callbacks, change values, and reenable\n self.unobserve(self.updateM, names='value', type= 'All')\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].unobserve(self.updateM, names='value')\n self.M_ = newM\n self.value = self.M_\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].value = self.M_[irow,icol]\n for irow in range(0,self.n):\n for icol in range(0,self.m):\n self.children[irow].children[icol].observe(self.updateM, names='value')\n self.observe(self.updateM, names='value', type= 'All') \n\n #self.children[irow].children[icol].observe(self.updateM, names='value')\n\n \n#overlaod class for state space systems that DO NOT remove \"useless\" states (what \"professor\" of automatic control would do this?)\nclass sss(control.StateSpace):\n def __init__(self,*args):\n #call base class init constructor\n control.StateSpace.__init__(self,*args)\n #disable function below in base class\n def _remove_useless_states(self):\n pass\n```\n\n\n```python\n# Preparatory cell\n\nA = numpy.matrix('1 0 3; 0 -4 -1; 0 1 -4')\nB = numpy.matrix('0; 0; 1')\nC = numpy.matrix('1 0 0')\nX0 = numpy.matrix('0.2; 0.2; 0.2')\nK = numpy.matrix([8/15,-4.4,-4])\nL = numpy.matrix([[23],[66],[107/3]])\n\nAw = matrixWidget(3,3)\nAw.setM(A)\nBw = matrixWidget(3,1)\nBw.setM(B)\nCw = matrixWidget(1,3)\nCw.setM(C)\nX0w = matrixWidget(3,1)\nX0w.setM(X0)\nKw = matrixWidget(1,3)\nKw.setM(K)\nLw = matrixWidget(3,1)\nLw.setM(L)\n\n\neig1c = matrixWidget(1,1)\neig2c = matrixWidget(2,1)\neig3c = matrixWidget(1,1)\neig1c.setM(numpy.matrix([-1.])) \neig2c.setM(numpy.matrix([[-1.],[0.]]))\neig3c.setM(numpy.matrix([-1.]))\n\neig1o = matrixWidget(1,1)\neig2o = matrixWidget(2,1)\neig3o = matrixWidget(1,1)\neig1o.setM(numpy.matrix([-10.])) \neig2o.setM(numpy.matrix([[-10.],[0.]]))\neig3o.setM(numpy.matrix([-10.]))\n```\n\n\n```python\n# Misc\n\n#create dummy widget \nDW = widgets.FloatText(layout=widgets.Layout(width='0px', height='0px'))\n\n#create button widget\nSTART = widgets.Button(\n description='Test',\n disabled=False,\n button_style='', # 'success', 'info', 'warning', 'danger' or ''\n tooltip='Test',\n icon='check'\n)\n \ndef on_start_button_clicked(b):\n #This is a workaround to have intreactive_output call the callback:\n # force the value of the dummy widget to change\n if DW.value> 0 :\n DW.value = -1\n else: \n DW.value = 1\n pass\nSTART.on_click(on_start_button_clicked)\n\n# Define type of method \nselm = widgets.Dropdown(\n options= ['Set K and L', 'Set the eigenvalues'],\n value= 'Set the eigenvalues',\n description='',\n disabled=False\n)\n\n# Define the number of complex eigenvalues\nsele = widgets.Dropdown(\n options= ['0 complex eigenvalues', '2 complex eigenvalues'],\n value= '0 complex eigenvalues',\n description='Complex eigenvalues:',\n style = {'description_width': 'initial'},\n disabled=False\n)\n\n#define type of ipout \nselu = widgets.Dropdown(\n options=['impulse', 'step', 'sinusoid', 'square wave'],\n value='step',\n description='Type of reference:',\n style = {'description_width': 'initial'},\n disabled=False\n)\n# Define the values of the input\nu = widgets.FloatSlider(\n value=1,\n min=0,\n max=20.0,\n step=0.1,\n description='Reference:',\n disabled=False,\n continuous_update=False,\n orientation='horizontal',\n readout=True,\n readout_format='.1f',\n)\nperiod = widgets.FloatSlider(\n value=0.5,\n min=0.01,\n max=4,\n step=0.01,\n description='Period: ',\n disabled=False,\n continuous_update=False,\n orientation='horizontal',\n readout=True,\n readout_format='.2f',\n)\n\ngain_w = widgets.FloatText(\n value=1.,\n description='',\n disabled=True\n)\n\ngain_id_w = widgets.FloatText(\n value=1.,\n description='',\n disabled=True\n)\n\ngain_w2 = widgets.FloatText(\n value=1.,\n description='',\n disabled=True\n)\n\ngain_id_w2 = widgets.FloatText(\n value=1.,\n description='',\n disabled=True\n)\n```\n\n\n```python\n# Support functions\n\ndef eigen_choice(sele):\n if sele == '0 complex eigenvalues':\n eig1c.children[0].children[0].disabled = False\n eig2c.children[1].children[0].disabled = True\n eig1o.children[0].children[0].disabled = False\n eig2o.children[1].children[0].disabled = True\n eig = 0\n if sele == '2 complex eigenvalues':\n eig1c.children[0].children[0].disabled = True\n eig2c.children[1].children[0].disabled = False\n eig1o.children[0].children[0].disabled = True\n eig2o.children[1].children[0].disabled = False\n eig = 2\n return eig\n\ndef method_choice(selm):\n if selm == 'Set K and L':\n method = 1\n sele.disabled = True\n if selm == 'Set the eigenvalues':\n method = 2\n sele.disabled = False\n return method\n```\n\n## Implementation as transfer function controller\n\n\n```python\nsols = numpy.linalg.eig(A)\n\ndef main_callback(Aw, Bw, X0w, K, L, eig1c, eig2c, eig3c, eig1o, eig2o, eig3o, u, period, selm, sele, selu, DW):\n eige = eigen_choice(sele)\n method = method_choice(selm)\n \n if method == 1:\n solc = numpy.linalg.eig(A-B*K)\n solo = numpy.linalg.eig(A-L*C)\n if method == 2:\n if eige == 0:\n K = control.acker(A, B, [eig1c[0,0], eig2c[0,0], eig3c[0,0]])\n Kw.setM(K)\n L = control.acker(A.T, C.T, [eig1o[0,0], eig2o[0,0], eig3o[0,0]]).T\n Lw.setM(L)\n if eige == 2:\n K = control.acker(A, B, [eig3c[0,0], \n numpy.complex(eig2c[0,0],eig2c[1,0]), \n numpy.complex(eig2c[0,0],-eig2c[1,0])])\n Kw.setM(K)\n L = control.acker(A.T, C.T, [eig3o[0,0], \n numpy.complex(eig2o[0,0],eig2o[1,0]), \n numpy.complex(eig2o[0,0],-eig2o[1,0])]).T\n Lw.setM(L)\n \n \n Gs = sss(A,B,C,0)\n Ks = sss(A-B*K-L*C,L,-K,0)\n Fs = control.series(-Ks,Gs)\n sys = control.feedback(Fs)\n \n Gs_id = sss(A,B,sym.eye(3),sym.zeros(3,1))\n Fs_id = control.series(K,Gs_id)\n A1 = numpy.matrix(Fs_id.A-Fs_id.B*Fs_id.C)\n B1 = numpy.matrix(Fs_id.B*sym.Matrix([[1],[0],[0]]))\n C1 = numpy.matrix(sym.Matrix([1,0,0]).T*Fs_id.C)\n sys_id = sss(A1,B1,C1,0)\n \n sys_o = sss(A-L*C,numpy.hstack((L,B)),sym.eye(3),sym.zeros(3,2))\n \n dcgain = control.dcgain(sys)\n t = numpy.linspace(0, 1000, 2)\n t, y = control.step_response(sys_id,t)\n dcgain_id = y[-1]\n gain_w.value = dcgain\n gain_id_w.value = dcgain_id\n if dcgain != 0 and dcgain_id != 0:\n u1 = u/gain_w.value\n u2 = u/gain_id_w.value\n else:\n print('The inverse gain set is 0 and it is changed to 1')\n u1 = u/1\n u2 = u/1\n \n solc = numpy.linalg.eig(sys.A)\n solo = numpy.linalg.eig(A-L*C-B*K)\n print('The system\\'s eigenvalues are:', round(sols[0][0],2),',', round(sols[0][1],2),'and', round(sols[0][2],2))\n print('The controlled closed loop system\\'s eigenvalues are:', \n round(solc[0][0],2),',', \n round(solc[0][1],2),',', \n round(solc[0][2],2),',',\n round(solc[0][3],2),',',\n round(solc[0][4],2),'and',\n round(solc[0][5],2))\n print('The controller\\'s eigenvalues are:', round(solo[0][0],2),',', round(solo[0][1],2),'and', round(solo[0][2],2))\n print('')\n print('The static gain of the closed loop system (from the reference to the output) is: %.5f' %dcgain)\n print('The static gain of the closed loop ideal system (from the reference to the output) is: %.5f' %dcgain_id)\n \n X0w1 = numpy.matrix([[X0w[0,0]],[X0w[1,0]],[X0w[2,0]],[0],[0],[0]])\n T = numpy.linspace(0, 12, 1000)\n \n if selu == 'impulse': #selu\n U = [0 for t in range(0,len(T))]\n U[0] = u\n U1 = [0 for t in range(0,len(T))]\n U1[0] = u1\n U2 = [0 for t in range(0,len(T))]\n U2[0] = u2\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n T, yout_k, xout_k = control.forced_response(Ks,T,yout-U1,X0w)\n T, yout_o, xout_o = control.forced_response(sys_o,T,[yout,yout_k],X0w)\n if selu == 'step':\n U = [u for t in range(0,len(T))]\n U1 = [u1 for t in range(0,len(T))]\n U2 = [u2 for t in range(0,len(T))]\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n T, yout_k, xout_k = control.forced_response(Ks,T,yout-U1,X0w)\n T, yout_o, xout_o = control.forced_response(sys_o,T,[yout,yout_k],X0w)\n if selu == 'sinusoid':\n U = u*numpy.sin(2*numpy.pi/period*T)\n U1 = u1*numpy.sin(2*numpy.pi/period*T)\n U2 = u2*numpy.sin(2*numpy.pi/period*T)\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n T, yout_k, xout_k = control.forced_response(Ks,T,yout-U1,X0w)\n T, yout_o, xout_o = control.forced_response(sys_o,T,[yout,yout_k],X0w)\n if selu == 'square wave':\n U = u*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n U1 = u1*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n U2 = u2*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n T, yout_k, xout_k = control.forced_response(Ks,T,yout-U1,X0w)\n T, yout_o, xout_o = control.forced_response(sys_o,T,[yout,yout_k],X0w)\n # N.B. i primi 3 stati di xout sono quelli dello stimatore, mentre gli ultimi 3 sono quelli del sistema \"reale\"\n \n fig = plt.figure(num='Simulation1', figsize=(16,17))\n mag, phase, omega = control.bode_plot(sys,Plot = False)\n mag = control.mag2db(mag)\n phase = phase*180/numpy.pi\n fig.add_subplot(321)\n plt.title('Bode plot: magnitude')\n plt.semilogx(omega,mag)\n plt.xlabel('$\\omega$ [rad/s]')\n plt.ylabel('Mag. [dB]')\n plt.grid(True,which=\"both\")\n \n fig.add_subplot(323)\n plt.title('Bode plot: phase')\n plt.semilogx(omega,phase)\n plt.xlabel('$\\omega$ [rad/s]')\n plt.ylabel('Phase [deg]')\n plt.grid(True,which=\"both\")\n \n fig.add_subplot(325)\n plt.title('Output response')\n plt.ylabel('Output')\n plt.plot(T,yout,T,yout_id,'g',T,U,'r--')\n plt.xlabel('$t$ [s]')\n plt.legend(['$y$','$y_{ideal}$','Reference'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \n fig.add_subplot(322)\n plt.title('First state response')\n plt.ylabel('$x_1$')\n plt.plot(T,xout_o[0],T,xout[3],T,xout_id[0],'g')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_{1est}$','$x_{1real}$','$x_{1ideal}$'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \n fig.add_subplot(324)\n plt.title('Second state response')\n plt.ylabel('$x_2$')\n plt.plot(T,xout_o[1],T,xout[4],T,xout_id[1],'g')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_{2est}$','$x_{2real}$','$x_{2ideal}$'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \n fig.add_subplot(326)\n plt.title('Third state response')\n plt.ylabel('$x_3$')\n plt.plot(T,xout_o[2],T,xout[5],T,xout_id[2],'g')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_{3est}$','$x_{3real}$','$x_{3ideal}$'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n\n \nalltogether = widgets.VBox([widgets.HBox([selm, \n sele,\n selu]),\n widgets.Label(' ',border=3),\n widgets.HBox([widgets.Label('K:',border=3), Kw, \n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('Eigenvalues:',border=3), \n eig1c, \n eig2c, \n eig3c,\n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('X0 est.:',border=3), X0w]),\n widgets.Label(' ',border=3),\n widgets.HBox([widgets.Label('L:',border=3), Lw, \n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('Eigenvalues:',border=3), \n eig1o, \n eig2o, \n eig3o,\n widgets.Label(' ',border=3),\n widgets.VBox([widgets.Label('Inverse reference gain:',border=3),\n widgets.Label('Inverse ideal reference gain:',border=3)]),\n widgets.VBox([gain_w,gain_id_w])]),\n widgets.Label(' ',border=3),\n widgets.HBox([u, \n period, \n START])])\nout = widgets.interactive_output(main_callback, {'Aw':Aw, 'Bw':Bw, 'X0w':X0w, 'K':Kw, 'L':Lw,\n 'eig1c':eig1c, 'eig2c':eig2c, 'eig3c':eig3c, 'eig1o':eig1o, 'eig2o':eig2o, 'eig3o':eig3o, \n 'u':u, 'period':period, 'selm':selm, 'sele':sele, 'selu':selu, 'DW':DW})\nout.layout.height = '1120px'\ndisplay(out, alltogether)\n```\n\n\n Output(layout=Layout(height='1120px'))\n\n\n\n VBox(children=(HBox(children=(Dropdown(index=1, options=('Set K and L', 'Set the eigenvalues'), value='Set the…\n\n\n## Implementation as observer\n\n\n```python\nsols = numpy.linalg.eig(A)\n\ndef main_callback2(Aw, Bw, X0w, K, L, eig1c, eig2c, eig3c, eig1o, eig2o, eig3o, u, period, selm, sele, selu, DW):\n eige = eigen_choice(sele)\n method = method_choice(selm)\n \n if method == 1:\n solc = numpy.linalg.eig(A-B*K)\n solo = numpy.linalg.eig(A-L*C)\n if method == 2:\n if eige == 0:\n K = control.acker(A, B, [eig1c[0,0], eig2c[0,0], eig3c[0,0]])\n Kw.setM(K)\n L = control.acker(A.T, C.T, [eig1o[0,0], eig2o[0,0], eig3o[0,0]]).T\n Lw.setM(L)\n if eige == 2:\n K = control.acker(A, B, [eig3c[0,0], \n numpy.complex(eig2c[0,0],eig2c[1,0]), \n numpy.complex(eig2c[0,0],-eig2c[1,0])])\n Kw.setM(K)\n L = control.acker(A.T, C.T, [eig3o[0,0], \n numpy.complex(eig2o[0,0],eig2o[1,0]), \n numpy.complex(eig2o[0,0],-eig2o[1,0])]).T\n Lw.setM(L)\n \n \n Gs = sss(A,B,numpy.vstack((numpy.eye(3),[0,0,0])),[[0],[0],[0],[1]])\n Os = sss(A-L*C,numpy.hstack((L,B)),numpy.vstack((-K,numpy.eye(3))),[[0,0],[0,0],[0,0],[0,0]])\n Gas = control.append(Gs,Os)\n sys = control.connect(Gas,[[2,1],[3,4],[1,5]],[1],[1,2,3,6,7,8])\n \n Gs_id = sss(A,B,sym.eye(3),sym.zeros(3,1))\n Fs_id = control.series(K,Gs_id)\n A1 = numpy.matrix(Fs_id.A-Fs_id.B*Fs_id.C)\n B1 = numpy.matrix(Fs_id.B*sym.Matrix([[1],[0],[0]]))\n C1 = numpy.matrix(sym.Matrix([1,0,0]).T*Fs_id.C)\n sys_id = sss(A1,B1,C1,0)\n\n \n dcgain = control.dcgain(sys[0,0])\n t = numpy.linspace(0, 1000, 2)\n t, y = control.step_response(sys_id,t)\n dcgain_id = y[-1]\n gain_w2.value = dcgain\n gain_id_w2.value = dcgain_id\n if dcgain != 0 and dcgain_id != 0:\n u1 = u/gain_w2.value\n u2 = u/gain_id_w2.value\n else:\n print('The inverse gain setted is 0 and it is changed to 1')\n u1 = u/1\n u2 = u/1\n \n solc = numpy.linalg.eig(sys.A)\n print('The system\\'s eigenvalues are:', round(sols[0][0],2),',', round(sols[0][1],2),'and', round(sols[0][2],2))\n print('The controlled closed loop system\\'s eigenvalues are:', \n round(solc[0][0],2),',', \n round(solc[0][1],2),',', \n round(solc[0][2],2),',',\n round(solc[0][3],2),',',\n round(solc[0][4],2),'and',\n round(solc[0][5],2))\n print('')\n print('The static gain of the closed loop system (from the reference to the output) is: %.5f' %dcgain)\n print('The static gain of the closed loop ideal system (from the reference to the output) is: %.5f' %dcgain_id)\n \n X0w1 = numpy.matrix([[0],[0],[0],[X0w[0,0]],[X0w[1,0]],[X0w[2,0]]])\n T = numpy.linspace(0, 12, 1000)\n \n if selu == 'impulse': #selu\n U = [0 for t in range(0,len(T))]\n U[0] = u\n U1 = [0 for t in range(0,len(T))]\n U1[0] = u1\n U2 = [0 for t in range(0,len(T))]\n U2[0] = u2\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n if selu == 'step':\n U = [u for t in range(0,len(T))]\n U1 = [u1 for t in range(0,len(T))]\n U2 = [u2 for t in range(0,len(T))]\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n if selu == 'sinusoid':\n U = u*numpy.sin(2*numpy.pi/period*T)\n U1 = u1*numpy.sin(2*numpy.pi/period*T)\n U2 = u2*numpy.sin(2*numpy.pi/period*T)\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n if selu == 'square wave':\n U = u*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n U1 = u1*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n U2 = u2*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n T, yout, xout = control.forced_response(sys,T,U1,X0w1)\n T, yout_id, xout_id = control.forced_response(sys_id,T,U2,[0, 0, 0])\n # N.B. i primi 3 stati di xout sono quelli del sistema, mentre gli ultimi 3 sono quelli dell'osservatore\n \n fig = plt.figure(num='Simulation1', figsize=(16,17))\n mag, phase, omega = control.bode_plot(sys[0,0],Plot = False)\n mag = control.mag2db(mag)\n phase = phase*180/numpy.pi\n fig.add_subplot(321)\n plt.title('Bode plot: magnitude')\n plt.semilogx(omega,mag)\n plt.xlabel('$\\omega$ [rad/s]')\n plt.ylabel('Mag. [dB]')\n plt.grid(True,which=\"both\")\n \n fig.add_subplot(323)\n plt.semilogx(omega,phase)\n plt.title('Bode plot: phase')\n plt.xlabel('$\\omega$ [rad/s]')\n plt.ylabel('Phase [deg]')\n plt.grid(True,which=\"both\")\n \n fig.add_subplot(325)\n plt.title('Output response')\n plt.ylabel('Output')\n plt.plot(T,yout[0],T,yout_id,'g',T,U,'r--')\n plt.xlabel('$t$ [s]')\n plt.legend(['$y$','$y_{ideal}$','Reference'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \n fig.add_subplot(322)\n plt.title('First state response')\n plt.ylabel('$x_1$')\n plt.plot(T,yout[3],T,yout[0],T,xout_id[0],'g')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_{1est}$','$x_{1real}$','$x_{1ideal}$'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \n fig.add_subplot(324)\n plt.title('Second state response')\n plt.ylabel('$x_2$')\n plt.plot(T,yout[4],T,yout[1],T,xout_id[1],'g')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_{2est}$','$x_{2real}$','$x_{2ideal}$'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \n fig.add_subplot(326)\n plt.title('Third state response')\n plt.ylabel('$x_3$')\n plt.plot(T,yout[5],T,yout[2],T,xout_id[2],'g')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_{3est}$','$x_{3real}$','$x_{3ideal}$'])\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \nalltogether2 = widgets.VBox([widgets.HBox([selm, \n sele,\n selu]),\n widgets.Label(' ',border=3),\n widgets.HBox([widgets.Label('K:',border=3), Kw, \n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('Eigenvalues:',border=3), \n eig1c, \n eig2c, \n eig3c,\n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('X0 est.:',border=3), X0w]),\n widgets.Label(' ',border=3),\n widgets.HBox([widgets.Label('L:',border=3), Lw, \n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('Eigenvalues:',border=3), \n eig1o, \n eig2o, \n eig3o,\n widgets.Label(' ',border=3),\n widgets.VBox([widgets.Label('Inverse reference gain:',border=3),\n widgets.Label('Inverse ideal reference gain:',border=3)]),\n widgets.VBox([gain_w2,gain_id_w2])]),\n widgets.Label(' ',border=3),\n widgets.HBox([u, \n period, \n START])])\nout2 = widgets.interactive_output(main_callback2, {'Aw':Aw, 'Bw':Bw, 'X0w':X0w, 'K':Kw, 'L':Lw,\n 'eig1c':eig1c, 'eig2c':eig2c, 'eig3c':eig3c, 'eig1o':eig1o, 'eig2o':eig2o, 'eig3o':eig3o, \n 'u':u, 'period':period, 'selm':selm, 'sele':sele, 'selu':selu, 'DW':DW})\nout2.layout.height = '1120px'\ndisplay(out2, alltogether2)\n```\n\n\n Output(layout=Layout(height='1120px'))\n\n\n\n VBox(children=(HBox(children=(Dropdown(index=1, options=('Set K and L', 'Set the eigenvalues'), value='Set the…\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "660f2ec5bcc01a1ed569cccf09b32cf5f24dfd42", "size": 38948, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_en/examples/04/SS-34-Regulator_design.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT/ENG/examples/04/SS-34-Regulator_design.ipynb", "max_issues_repo_name": "tuxsaurus/ICCT", "max_issues_repo_head_hexsha": "30d1aea4fb056c9736c9b4c5a0f50fff14fa6382", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT/ENG/examples/04/SS-34-Regulator_design.ipynb", "max_forks_repo_name": "tuxsaurus/ICCT", "max_forks_repo_head_hexsha": "30d1aea4fb056c9736c9b4c5a0f50fff14fa6382", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 42.060475162, "max_line_length": 365, "alphanum_fraction": 0.4689329362, "converted": true, "num_tokens": 8436, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268347662043286, "lm_q2_score": 0.23934933647101644, "lm_q1q2_score": 0.11313647648991382}}
{"text": "```python\nfrom IPython.core.display import HTML, Image\ncss_file = 'style.css'\nHTML(open(css_file, 'r').read())\n```\n\n\n\n\n.\"\"\"\n\n def __init__(self):\n pass\n\n def get_gradient_circuits(self, programs, symbol_names, symbol_values):\n \"\"\"Return circuits to compute gradients for given forward pass circuits.\n \n Every gradient on a quantum computer can be computed via measurements\n of transformed quantum circuits. Here, you implement a custom gradient\n for a specific circuit. For a real differentiator, you will need to\n implement this function in a more general way. See the differentiator\n implementations in the TFQ library for examples.\n \"\"\"\n\n # The two terms in the derivative are the same circuit...\n batch_programs = tf.stack([programs, programs], axis=1)\n\n # ... with shifted parameter values.\n shift = tf.constant(1/2)\n forward = symbol_values + shift\n backward = symbol_values - shift\n batch_symbol_values = tf.stack([forward, backward], axis=1)\n \n # Weights are the coefficients of the terms in the derivative.\n num_program_copies = tf.shape(batch_programs)[0]\n batch_weights = tf.tile(tf.constant([[[np.pi/2, -np.pi/2]]]),\n [num_program_copies, 1, 1])\n\n # The index map simply says which weights go with which circuits.\n batch_mapper = tf.tile(\n tf.constant([[[0, 1]]]), [num_program_copies, 1, 1])\n\n return (batch_programs, symbol_names, batch_symbol_values,\n batch_weights, batch_mapper)\n```\n\nThe `Differentiator` base class uses the components returned from `get_gradient_circuits` to calculate the derivative, as in the parameter shift formula you saw above. This new differentiator can now be used with existing `tfq.layer` objects:\n\n\n```\ncustom_dif = MyDifferentiator()\ncustom_grad_expectation = tfq.layers.Expectation(differentiator=custom_dif)\n\n# Now let's get the gradients with finite diff.\nwith tf.GradientTape() as g:\n g.watch(values_tensor)\n exact_outputs = expectation_calculation(my_circuit,\n operators=[pauli_x],\n symbol_names=['alpha'],\n symbol_values=values_tensor)\n\nanalytic_finite_diff_gradients = g.gradient(exact_outputs, values_tensor)\n\n# Now let's get the gradients with custom diff.\nwith tf.GradientTape() as g:\n g.watch(values_tensor)\n my_outputs = custom_grad_expectation(my_circuit,\n operators=[pauli_x],\n symbol_names=['alpha'],\n symbol_values=values_tensor)\n\nmy_gradients = g.gradient(my_outputs, values_tensor)\n\nplt.subplot(1, 2, 1)\nplt.title('Exact Gradient')\nplt.plot(input_points, analytic_finite_diff_gradients.numpy())\nplt.xlabel('x')\nplt.ylabel('f(x)')\nplt.subplot(1, 2, 2)\nplt.title('My Gradient')\nplt.plot(input_points, my_gradients.numpy())\nplt.xlabel('x')\n```\n\nThis new differentiator can now be used to generate differentiable ops.\n\nKey Point: A differentiator that has been previously attached to an op must be refreshed before attaching to a new op, because a differentiator may only be attached to one op at a time.\n\n\n```\n# Create a noisy sample based expectation op.\nexpectation_sampled = tfq.get_sampled_expectation_op(\n cirq.DensityMatrixSimulator(noise=cirq.depolarize(0.01)))\n\n# Make it differentiable with your differentiator:\n# Remember to refresh the differentiator before attaching the new op\ncustom_dif.refresh()\ndifferentiable_op = custom_dif.generate_differentiable_op(\n sampled_op=expectation_sampled)\n\n# Prep op inputs.\ncircuit_tensor = tfq.convert_to_tensor([my_circuit])\nop_tensor = tfq.convert_to_tensor([[pauli_x]])\nsingle_value = tf.convert_to_tensor([[my_alpha]])\nnum_samples_tensor = tf.convert_to_tensor([[5000]])\n\nwith tf.GradientTape() as g:\n g.watch(single_value)\n forward_output = differentiable_op(circuit_tensor, ['alpha'], single_value,\n op_tensor, num_samples_tensor)\n\nmy_gradients = g.gradient(forward_output, single_value)\n\nprint('---TFQ---')\nprint('Foward: ', forward_output.numpy())\nprint('Gradient:', my_gradients.numpy())\nprint('---Original---')\nprint('Forward: ', my_expectation(pauli_x, my_alpha))\nprint('Gradient:', my_grad(pauli_x, my_alpha))\n```\n\nSuccess: Now you can use all the differentiators that TensorFlow Quantum has to offer—and define your own.\n", "meta": {"hexsha": "0a8a9077155cf91f8278b40dc2246f0be1fc6528", "size": 28174, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "site/en-snapshot/quantum/tutorials/gradients.ipynb", "max_stars_repo_name": "wanggdnju/docs-l10n", "max_stars_repo_head_hexsha": "4775692c820ce24babcaf2f29f6130195f7ff509", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-12-14T09:14:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T09:14:16.000Z", "max_issues_repo_path": "site/en-snapshot/quantum/tutorials/gradients.ipynb", "max_issues_repo_name": "wanggdnju/docs-l10n", "max_issues_repo_head_hexsha": "4775692c820ce24babcaf2f29f6130195f7ff509", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "site/en-snapshot/quantum/tutorials/gradients.ipynb", "max_forks_repo_name": "wanggdnju/docs-l10n", "max_forks_repo_head_hexsha": "4775692c820ce24babcaf2f29f6130195f7ff509", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2279511533, "max_line_length": 615, "alphanum_fraction": 0.5337190317, "converted": true, "num_tokens": 3792, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.23370635157681108, "lm_q1q2_score": 0.11229091885702559}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ndisplay(HTML(''))\n```\n\n\n\nToggle cell visibility here . \n\n\n\n```python\n%matplotlib notebook\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport sympy as sym\nimport scipy.signal as signal\nfrom ipywidgets import widgets, interact\nimport control as cn\n```\n\n## Root locus\n\nRoot locus is a plot of the location of closed-loop system poles in relation with a certain parameter (typically amplification). It can be shown that the curves start in the open-loop poles and end up in the open-loop zeros (or infinity). The location of closed-loop system poles not only gives an indication of system stability, but other closed-loop system response properties such as overshoot, rise time and settling time can also be inferred from pole location.\n\n---\n\n### How to use this notebook?\n1. Click on *P0*, *P1*, *I0* or *I1* to toggle between the following objects: proportional of the zeroth, first or second order, or an integral one of zeroth or first order. The transfer function of P0 object is $k_p$ (in this example $k_p=2$), of PI object $\\frac{k_p}{\\tau s+1}$ (in this example $k_p=1$ and $\\tau=2$), of IO object $\\frac{k_i}{s}$ (in this example $k_i=\\frac{1}{10}$) and of I1 object $\\frac{k_i}{s(\\tau s +1)}$ (in this example $k_i=1$ and $\\tau=10$).\n2. Click on the *P*, *PI*, *PD* or *PID* button to toogle between proportional, proportional-integral, proportional-derivative or proportional–integral–derivative control algorithm types.\n3. Move the sliders to change the values of proportional ($K_p$), integral ($T_i$) and derivative ($T_d$) PID tunning coefficients.\n4. Move the slider $t_{max}$ to change the maximum value of the time on x axis.\n\n\n```python\nA = 10\na=0.1\ns, P, I, D = sym.symbols('s, P, I, D')\n\nobj = 1/(A*s)\nPID = P + P/(I*s) + P*D*s#/(a*D*s+1)\nsystem = obj*PID/(1+obj*PID)\nnum = [sym.fraction(system.factor())[0].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system.factor())[0], gen=s)))]\nden = [sym.fraction(system.factor())[1].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system.factor())[1], gen=s)))]\nsystem_func_open = obj*PID\nnum_open = [sym.fraction(system_func_open.factor())[0].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func_open.factor())[0], gen=s)))]\nden_open = [sym.fraction(system_func_open.factor())[1].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func_open.factor())[1], gen=s)))]\n \n# make figure\nfig = plt.figure(figsize=(9.8, 4),num='Root locus')\nplt.subplots_adjust(wspace=0.3)\n\n# add axes\nax = fig.add_subplot(121)\nax.grid(which='both', axis='both', color='lightgray')\nax.set_title('Time response')\nax.set_xlabel('t [s]')\nax.set_ylabel('input, output')\n\nrlocus = fig.add_subplot(122)\n\n\n# plot step function and responses (initalisation)\ninput_plot, = ax.plot([],[],'C0', lw=1, label='input')\nresponse_plot, = ax.plot([],[], 'C1', lw=2, label='output')\nax.legend()\n\nrlocus_plot, = rlocus.plot([], [], 'r')\n\nplt.show()\n\nsystem_open = None\nsystem_close = None\ndef update_plot(KP, TI, TD, Time_span):\n global num, den, num_open, den_open\n global system_open, system_close\n num_temp = [float(i.subs(P,KP).subs(I,TI).subs(D,TD)) for i in num]\n den_temp = [float(i.subs(P,KP).subs(I,TI).subs(D,TD)) for i in den]\n system = signal.TransferFunction(num_temp, den_temp)\n system_close = system\n num_temp_open = [float(i.subs(P,KP).subs(I,TI).subs(D,TD)) for i in num_open]\n den_temp_open = [float(i.subs(P,KP).subs(I,TI).subs(D,TD)) for i in den_open]\n system_open = signal.TransferFunction(num_temp_open, den_temp_open)\n \n rlocus.clear()\n r, k, xlim, ylim = cn.root_locus_modified(system_open, Plot=False)\n# r, k = cn.root_locus(system_open, Plot=False)\n #rlocus.scatter(r)\n #plot closed loop poles and zeros\n poles = np.roots(system.den)\n rlocus.plot(np.real(poles), np.imag(poles), 'kx')\n zeros = np.roots(system.num)\n if zeros.size > 0:\n rlocus.plot(np.real(zeros), np.imag(zeros), 'ko', alpha=0.5)\n # plot open loop poles and zeros\n poles = np.roots(system_open.den)\n rlocus.plot(np.real(poles), np.imag(poles), 'x', alpha=0.5)\n zeros = np.roots(system_open.num)\n if zeros.size > 0:\n rlocus.plot(np.real(zeros), np.imag(zeros), 'o')\n #plot root locus\n for index, col in enumerate(r.T):\n rlocus.plot(np.real(col), np.imag(col), 'b', alpha=0.5)\n \n rlocus.set_title('Root locus')\n rlocus.set_xlabel('Re')\n rlocus.set_ylabel('Im')\n rlocus.grid(which='both', axis='both', color='lightgray')\n \n rlocus.axhline(linewidth=.3, color='g')\n rlocus.axvline(linewidth=.3, color='g')\n rlocus.set_ylim(ylim)\n rlocus.set_xlim(xlim)\n \n time = np.linspace(0, Time_span, 300)\n u = np.ones_like(time)\n u[0] = 0\n time, response = signal.step(system, T=time)\n \n response_plot.set_data(time, response)\n input_plot.set_data(time, u)\n \n ax.set_ylim([min([np.min(u), min(response),-.1]),min(100,max([max(response)*1.05, 1, 1.05*np.max(u)]))])\n ax.set_xlim([-0.1,max(time)])\n\n plt.show()\n\ncontroller_ = PID\nobject_ = obj\n\ndef calc_tf():\n global num, den, controller_, object_, num_open, den_open\n system_func = object_*controller_/(1+object_*controller_)\n \n num = [sym.fraction(system_func.factor())[0].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func.factor())[0], gen=s)))]\n den = [sym.fraction(system_func.factor())[1].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func.factor())[1], gen=s)))]\n \n system_func_open = object_*controller_\n num_open = [sym.fraction(system_func_open.factor())[0].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func_open.factor())[0], gen=s)))]\n den_open = [sym.fraction(system_func_open.factor())[1].expand().coeff(s, i) for i in reversed(range(1+sym.degree(sym.fraction(system_func_open.factor())[1], gen=s)))]\n \n update_plot(Kp_widget.value, Ti_widget.value, Td_widget.value, time_span_widget.value)\n\ndef transfer_func(controller_type):\n global controller_\n proportional = P\n integral = P/(I*s)\n differential = P*D*s/(a*D*s+1)\n if controller_type =='P':\n controller_func = proportional\n Kp_widget.disabled=False\n Ti_widget.disabled=True\n Td_widget.disabled=True\n elif controller_type =='PI':\n controller_func = proportional+integral\n Kp_widget.disabled=False\n Ti_widget.disabled=False\n Td_widget.disabled=True\n elif controller_type == 'PD':\n controller_func = proportional+differential\n Kp_widget.disabled=False\n Ti_widget.disabled=True\n Td_widget.disabled=False\n else:\n controller_func = proportional+integral+differential\n Kp_widget.disabled=False\n Ti_widget.disabled=False\n Td_widget.disabled=False\n \n controller_ = controller_func\n calc_tf()\n \ndef transfer_func_obj(object_type):\n global object_\n if object_type == 'P0':\n object_ = 2\n elif object_type == 'P1':\n object_ = 1/(2*s+1) \n elif object_type == 'I0':\n object_ = 1/(10*s)\n elif object_type == 'I1':\n object_ = 1/(s*(10*s+1))\n calc_tf()\n\nstyle = {'description_width': 'initial'}\n\ndef buttons_controller_clicked(event):\n controller = buttons_controller.options[buttons_controller.index]\n transfer_func(controller)\nbuttons_controller = widgets.ToggleButtons(\n options=['P', 'PI', 'PD', 'PID'],\n description='Select control algorithm type:',\n disabled=False,\n style=style)\nbuttons_controller.observe(buttons_controller_clicked)\n\ndef buttons_object_clicked(event):\n object_ = buttons_object.options[buttons_object.index]\n transfer_func_obj(object_)\nbuttons_object = widgets.ToggleButtons(\n options=['P0', 'P1', 'I0', 'I1'],\n description='Select object:',\n disabled=False,\n style=style)\nbuttons_object.observe(buttons_object_clicked)\n\n \nKp_widget = widgets.FloatLogSlider(value=.5,min=-3,max=2.1,step=.001,description=r'\\(K_p\\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.3f')\nTi_widget = widgets.FloatLogSlider(value=1.,min=-3,max=1.8,step=.001,description=r'\\(T_{i} \\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.3f')\nTd_widget = widgets.FloatLogSlider(value=1.,min=-3,max=1.8,step=.001,description=r'\\(T_{d} \\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.3f')\n\ntime_span_widget = widgets.FloatSlider(value=10.,min=.5,max=50.,step=0.1,description=r'\\(t_{max} \\)',\n disabled=False,continuous_update=True,orientation='horizontal',readout=True,readout_format='.1f')\n\ntransfer_func(buttons_controller.options[buttons_controller.index])\ntransfer_func_obj(buttons_object.options[buttons_object.index])\n\ndisplay(buttons_object)\ndisplay(buttons_controller)\n\ninteract(update_plot, KP=Kp_widget, TI=Ti_widget, TD=Td_widget, Time_span=time_span_widget);\n```\n\n\n \n\n\n\n\n\n\n\n ToggleButtons(description='Select object:', options=('P0', 'P1', 'I0', 'I1'), style=ToggleButtonsStyle(descrip…\n\n\n\n ToggleButtons(description='Select control algorithm type:', options=('P', 'PI', 'PD', 'PID'), style=ToggleButt…\n\n\n\n interactive(children=(FloatLogSlider(value=0.5, description='\\\\(K_p\\\\)', max=2.1, min=-3.0, readout_format='.3…\n\n", "meta": {"hexsha": "72bfa549fcb0e1fe0db0e4dde60b5bdb8b346bbf", "size": 127629, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_en/examples/02/.ipynb_checkpoints/TD-18-Root-locus-checkpoint.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT/ENG/examples/02/TD-18-Root-locus.ipynb", "max_issues_repo_name": "tuxsaurus/ICCT", "max_issues_repo_head_hexsha": "30d1aea4fb056c9736c9b4c5a0f50fff14fa6382", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT/ENG/examples/02/TD-18-Root-locus.ipynb", "max_forks_repo_name": "tuxsaurus/ICCT", "max_forks_repo_head_hexsha": "30d1aea4fb056c9736c9b4c5a0f50fff14fa6382", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 113.1462765957, "max_line_length": 78867, "alphanum_fraction": 0.7907998966, "converted": true, "num_tokens": 2641, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4687906266262438, "lm_q2_score": 0.23934934189686402, "lm_q1q2_score": 0.11220472797040996}}
{"text": "\n# PHY321: Forces, Newton's Laws and Motion Example\n\n \n**[Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/)**, Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University, USA and Department of Physics, University of Oslo, Norway \n\n **[Scott Pratt](https://pa.msu.edu/profile/pratts/)**, Department of Physics and Astronomy and National Superconducting Cyclotron Laboratory, Michigan State University, USA \n\n **[Carl Schmidt](https://pa.msu.edu/profile/schmidt/)**, Department of Physics and Astronomy, Michigan State University, USA\n\nDate: **Dec 16, 2020**\n\nCopyright 1999-2020, [Morten Hjorth-Jensen](http://mhjgit.github.io/info/doc/web/). Released under CC Attribution-NonCommercial 4.0 license\n\n\n\n\n\n# Basic Steps of Scientific Investigations\n\nAn overarching aim in this course is to give you a deeper\nunderstanding of the scientific method. The problems we study will all\ninvolve cases where we can apply classical mechanics. In our previous\nmaterial we already assumed that we had a model for the motion of an\nobject. Alternatively we could have data from experiment (like Usain\nBolt's 100m world record run in 2008). Or we could have performed\nourselves an experiment and we want to understand which forces are at\nplay and whether these forces can be understood in terms of\nfundamental forces.\n\nOur first step consists in identifying the problem. What we sketch\nhere may include a mix of experiment and theoretical simulations, or\njust experiment or only theory.\n\n\n## Identifying our System\n\nHere we can ask questions like\n1. What kind of object is moving\n\n2. What kind of data do we have\n\n3. How do we measure position, velocity, acceleration etc\n\n4. Which initial conditions influence our system\n\n5. Other aspects which allow us to identify the system\n\n## Defining a Model\n\nWith our eventual data and observations we would now like to develop a\nmodel for the system. In the end we want obviously to be able to\nunderstand which forces are at play and how they influence our\nspecific system. That is, can we extract some deeper insights about a\nsystem?\n\nWe need then to\n1. Find the forces that act on our system\n\n2. Introduce models for the forces\n\n3. Identify the equations which can govern the system (Newton's second law for example)\n\n4. More elements we deem important for defining our model\n\n## Solving the Equations\n\nWith the model at hand, we can then solve the equations. In classical mechanics we normally end up with solving sets of coupled ordinary differential equations or partial differential equations.\n1. Using Newton's second law we have equations of the type $\\boldsymbol{F}=m\\boldsymbol{a}=md\\boldsymbol{v}/dt$\n\n2. We need to define the initial conditions (typically the initial velocity and position as functions of time) and/or initial conditions and boundary conditions\n\n3. The solution of the equations give us then the position, the velocity and other time-dependent quantities which may specify the motion of a given object.\n\nWe are not yet done. With our lovely solvers, we need to start thinking.\n\n\nNow it is time to ask the big questions. What do our results mean? Can we give a simple interpretation in terms of fundamental laws? What do our results mean? Are they correct?\nThus, typical questions we may ask are\n1. Are our results for say $\\boldsymbol{r}(t)$ valid? Do we trust what we did? Can you validate and verify the correctness of your results?\n\n2. Evaluate the answers and their implications\n\n3. Compare with experimental data if possible. Does our model make sense?\n\n4. and obviously many other questions.\n\nThe analysis stage feeds back to the first stage. It may happen that\nthe data we had were not good enough, there could be large statistical\nuncertainties. We may need to collect more data or perhaps we did a\nsloppy job in identifying the degrees of freedom.\n\nAll these steps are essential elements in a scientific\nenquiry. Hopefully, through a mix of numerical simulations, analytical\ncalculations and experiments we may gain a deeper insight about the\nphysics of a specific system.\n\nLet us now remind ourselves of Newton's laws, since these are the laws of motion we will study in this course.\n\n\n## Newton's Laws\n\nWhen analyzing a physical system we normally start with distinguishing between the object we are studying (we will label this in more general terms as our **system**) and how this system interacts with the environment (which often means everything else!)\n\nIn our investigations we will thus analyze a specific physics problem in terms of the system and the environment.\nIn doing so we need to identify the forces that act on the system and assume that the\nforces acting on the system must have a source, an identifiable cause in\nthe environment.\n\nA force acting on for example a falling object must be related to an interaction with something in the environment.\nThis also means that we do not consider internal forces. The latter are forces between\none part of the object and another part. In this course we will mainly focus on external forces.\n\nForces are either contact forces or long-range forces.\n\nContact forces, as evident from the name, are forces that occur at the contact between\nthe system and the environment. Well-known long-range forces are the gravitional force and the electromagnetic force.\n\n\n\n## Setting up a model for forces acting on an object\n\nIn order to set up the forces which act on an object, the following steps may be useful\n1. Divide the problem into system and environment.\n\n2. Draw a figure of the object and everything in contact with the object.\n\n3. Draw a closed curve around the system.\n\n4. Find contact points—these are the points where contact forces may act.\n\n5. Give names and symbols to all the contact forces.\n\n6. Identify the long-range forces.\n\n7. Make a drawing of the object. Draw the forces as arrows, vectors, starting from where the force is acting. The direction of the vector(s) indicates the (positive) direction of the force. Try to make the length of the arrow indicate the relative magnitude of the forces.\n\n8. Draw in the axes of the coordinate system. It is often convenient to make one axis parallel to the direction of motion. When you choose the direction of the axis you also choose the positive direction for the axis.\n\n## Newton's Laws, the Second one first\n\n\nNewton’s second law of motion: The force $\\boldsymbol{F}$ on an object of inertial mass $m$\nis related to the acceleration a of the object through\n\n$$\n\\boldsymbol{F} = m\\boldsymbol{a},\n$$\n\nwhere $\\boldsymbol{a}$ is the acceleration.\n\nNewton’s laws of motion are laws of nature that have been found by experimental\ninvestigations and have been shown to hold up to continued experimental investigations.\nNewton’s laws are valid over a wide range of length- and time-scales. We\nuse Newton’s laws of motion to describe everything from the motion of atoms to the\nmotion of galaxies.\n\nThe second law is a vector equation with the acceleration having the same\ndirection as the force. The acceleration is proportional to the force via the mass $m$ of the system under study.\n\n\nNewton’s second law introduces a new property of an object, the so-called \ninertial mass $m$. We determine the inertial mass of an object by measuring the\nacceleration for a given applied force.\n\n\n\n## Then the First Law\n\n\nWhat happens if the net external force on a body is zero? Applying Newton’s second\nlaw, we find:\n\n$$\n\\boldsymbol{F} = 0 = m\\boldsymbol{a},\n$$\n\nwhich gives using the definition of the acceleration\n\n$$\n\\boldsymbol{a} = \\frac{d\\boldsymbol{v}}{dt}=0.\n$$\n\nThe acceleration is zero, which means that the velocity of the object is constant. This\nis often referred to as Newton’s first law. An object in a state of uniform motion tends to remain in\nthat state unless an external force changes its state of motion.\nWhy do we need a separate law for this? Is it not simply a special case of Newton’s\nsecond law? Yes, Newton’s first law can be deduced from the second law as we have\nillustrated. However, the first law is often used for a different purpose: Newton’s\nFirst Law tells us about the limit of applicability of Newton’s Second law. Newton’s\nSecond law can only be used in reference systems where the First law is obeyed. But\nis not the First law always valid? No! The First law is only valid in reference systems\nthat are not accelerated. If you observe the motion of a ball from an accelerating\ncar, the ball will appear to accelerate even if there are no forces acting on it. We call\nsystems that are not accelerating inertial systems, and Newton’s first law is often\ncalled the law of inertia. Newton’s first and second laws of motion are only valid in\ninertial systems. \n\nA system is an inertial system if it is not accelerated. It means that the reference system\nmust not be accelerating linearly or rotating. Unfortunately, this means that most\nsystems we know are not really inertial systems. For example, the surface of the\nEarth is clearly not an inertial system, because the Earth is rotating. The Earth is also\nnot an inertial system, because it ismoving in a curved path around the Sun. However,\neven if the surface of the Earth is not strictly an inertial system, it may be considered\nto be approximately an inertial system for many laboratory-size experiments.\n\n\n## And finally the Third Law\n\n\nIf there is a force from object A on object B, there is also a force from object B on object A.\nThis fundamental principle of interactions is called Newton’s third law. We do not\nknow of any force that do not obey this law: All forces appear in pairs. Newton’s\nthird law is usually formulated as: For every action there is an equal and opposite\nreaction.\n\n\n\n## Motion of a Single Object\n\nHere we consider the motion of a single particle moving under\nthe influence of some set of forces. We will consider some problems where\nthe force does not depend on the position. In that case Newton's law\n$m\\dot{\\boldsymbol{v}}=\\boldsymbol{F}(\\boldsymbol{v})$ is a first-order differential\nequation and one solves for $\\boldsymbol{v}(t)$, then moves on to integrate\n$\\boldsymbol{v}$ to get the position. In essentially all of these cases we cna find an analytical solution.\n\n\n\n## Air Resistance in One Dimension\n\nAir resistance tends to scale as the square of the velocity. This is\nin contrast to many problems chosen for textbooks, where it is linear\nin the velocity. The choice of a linear dependence is motivated by\nmathematical simplicity (it keeps the differential equation linear)\nrather than by physics. One can see that the force should be quadratic\nin velocity by considering the momentum imparted on the air\nmolecules. If an object sweeps through a volume $dV$ of air in time\n$dt$, the momentum imparted on the air is\n\n\n
\n\n$$\n\\begin{equation}\ndP=\\rho_m dV v,\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nwhere $v$ is the velocity of the object and $\\rho_m$ is the mass\ndensity of the air. If the molecules bounce back as opposed to stop\nyou would double the size of the term. The opposite value of the\nmomentum is imparted onto the object itself. Geometrically, the\ndifferential volume is\n\n\n
\n\n$$\n\\begin{equation}\ndV=Avdt,\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nwhere $A$ is the cross-sectional area and $vdt$ is the distance the\nobject moved in time $dt$.\n\n\n## Resulting Acceleration\nPlugging this into the expression above,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dP}{dt}=-\\rho_m A v^2.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\nThis is the force felt by the particle, and is opposite to its\ndirection of motion. Now, because air doesn't stop when it hits an\nobject, but flows around the best it can, the actual force is reduced\nby a dimensionless factor $c_W$, called the drag coefficient.\n\n\n
\n\n$$\n\\begin{equation}\nF_{\\rm drag}=-c_W\\rho_m Av^2,\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nand the acceleration is\n\n$$\n\\begin{eqnarray}\n\\frac{dv}{dt}=-\\frac{c_W\\rho_mA}{m}v^2.\n\\end{eqnarray}\n$$\n\nFor a particle with initial velocity $v_0$, one can separate the $dt$\nto one side of the equation, and move everything with $v$s to the\nother side. We did this in our discussion of simple motion and will not repeat it here.\n\nOn more general terms,\nfor many systems, e.g. an automobile, there are multiple sources of\nresistance. In addition to wind resistance, where the force is\nproportional to $v^2$, there are dissipative effects of the tires on\nthe pavement, and in the axel and drive train. These other forces can\nhave components that scale proportional to $v$, and components that\nare independent of $v$. Those independent of $v$, e.g. the usual\n$f=\\mu_K N$ frictional force you consider in your first Physics courses, only set in\nonce the object is actually moving. As speeds become higher, the $v^2$\ncomponents begin to dominate relative to the others. For automobiles\nat freeway speeds, the $v^2$ terms are largely responsible for the\nloss of efficiency. To travel a distance $L$ at fixed speed $v$, the\nenergy/work required to overcome the dissipative forces are $fL$,\nwhich for a force of the form $f=\\alpha v^n$ becomes\n\n$$\n\\begin{eqnarray}\nW=\\int dx~f=\\alpha v^n L.\n\\end{eqnarray}\n$$\n\nFor $n=0$ the work is\nindependent of speed, but for the wind resistance, where $n=2$,\nslowing down is essential if one wishes to reduce fuel consumption. It\nis also important to consider that engines are designed to be most\nefficient at a chosen range of power output. Thus, some cars will get\nbetter mileage at higher speeds (They perform better at 50 mph than at\n5 mph) despite the considerations mentioned above.\n\n\n## Going Ballistic, Projectile Motion or a Softer Approach, Falling Raindrops\n\n\nAs an example of Newton's Laws we consider projectile motion (or a\nfalling raindrop or a ball we throw up in the air) with a drag force. Even though air resistance is\nlargely proportional to the square of the velocity, we will consider\nthe drag force to be linear to the velocity, $\\boldsymbol{F}=-m\\gamma\\boldsymbol{v}$,\nfor the purposes of this exercise. The acceleration for a projectile moving upwards,\n$\\boldsymbol{a}=\\boldsymbol{F}/m$, becomes\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{dt}=-\\gamma v_x,\\\\\n\\nonumber\n\\frac{dv_y}{dt}=-\\gamma v_y-g,\n\\end{eqnarray}\n$$\n\nand $\\gamma$ has dimensions of inverse time. \n\nIf you on the other hand have a falling raindrop, how do these equations change? See for example Figure 2.1 in Taylor.\nLet us stay with a ball which is thrown up in the air at $t=0$. \n\n\n## Ways of solving these equations\n\nWe will go over two different ways to solve this equation. The first\nby direct integration, and the second as a differential equation. To\ndo this by direct integration, one simply multiplies both sides of the\nequations above by $dt$, then divide by the appropriate factors so\nthat the $v$s are all on one side of the equation and the $dt$ is on\nthe other. For the $x$ motion one finds an easily integrable equation,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_x}{v_x}&=&-\\gamma dt,\\\\\n\\nonumber\n\\int_{v_{0x}}^{v_{x}}\\frac{dv_x}{v_x}&=&-\\gamma\\int_0^{t}dt,\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{x}}{v_{0x}}\\right)&=&-\\gamma t,\\\\\n\\nonumber\nv_{x}(t)&=&v_{0x}e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nThis is very much the result you would have written down\nby inspection. For the $y$-component of the velocity,\n\n$$\n\\begin{eqnarray}\n\\frac{dv_y}{v_y+g/\\gamma}&=&-\\gamma dt\\\\\n\\nonumber\n\\ln\\left(\\frac{v_{y}+g/\\gamma}{v_{0y}-g/\\gamma}\\right)&=&-\\gamma t_f,\\\\\n\\nonumber\nv_{fy}&=&-\\frac{g}{\\gamma}+\\left(v_{0y}+\\frac{g}{\\gamma}\\right)e^{-\\gamma t}.\n\\end{eqnarray}\n$$\n\nWhereas $v_x$ starts at some value and decays\nexponentially to zero, $v_y$ decays exponentially to the terminal\nvelocity, $v_t=-g/\\gamma$.\n\n\n## Solving as differential equations\n\nAlthough this direct integration is simpler than the method we invoke\nbelow, the method below will come in useful for some slightly more\ndifficult differential equations in the future. The differential\nequation for $v_x$ is straight-forward to solve. Because it is first\norder there is one arbitrary constant, $A$, and by inspection the\nsolution is\n\n\n
\n\n$$\n\\begin{equation}\nv_x=Ae^{-\\gamma t}.\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\nThe arbitrary constants for equations of motion are usually determined\nby the initial conditions, or more generally boundary conditions. By\ninspection $A=v_{0x}$, the initial $x$ component of the velocity.\n\n\n\n## Differential Equations, contn\n\nThe differential equation for $v_y$ is a bit more complicated due to\nthe presence of $g$. Differential equations where all the terms are\nlinearly proportional to a function, in this case $v_y$, or to\nderivatives of the function, e.g., $v_y$, $dv_y/dt$,\n$d^2v_y/dt^2\\cdots$, are called linear differential equations. If\nthere are terms proportional to $v^2$, as would happen if the drag\nforce were proportional to the square of the velocity, the\ndifferential equation is not longer linear. Because this expression\nhas only one derivative in $v$ it is a first-order linear differential\nequation. If a term were added proportional to $d^2v/dt^2$ it would be\na second-order differential equation. In this case we have a term\ncompletely independent of $v$, the gravitational acceleration $g$, and\nthe usual strategy is to first rewrite the equation with all the\nlinear terms on one side of the equal sign,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_y}{dt}+\\gamma v_y=-g.\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\n## Splitting into two parts\n\nNow, the solution to the equation can be broken into two\nparts. Because this is a first-order differential equation we know\nthat there will be one arbitrary constant. Physically, the arbitrary\nconstant will be determined by setting the initial velocity, though it\ncould be determined by setting the velocity at any given time. Like\nmost differential equations, solutions are not \"solved\". Instead,\none guesses at a form, then shows the guess is correct. For these\ntypes of equations, one first tries to find a single solution,\ni.e. one with no arbitrary constants. This is called the {\\it\nparticular} solution, $y_p(t)$, though it should really be called\n\"a\" particular solution because there are an infinite number of such\nsolutions. One then finds a solution to the {\\it homogenous} equation,\nwhich is the equation with zero on the right-hand side,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,h}}{dt}+\\gamma v_{y,h}=0.\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nHomogenous solutions will have arbitrary constants. \n\nThe particular solution will solve the same equation as the original\ngeneral equation\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{dv_{y,p}}{dt}+\\gamma v_{y,p}=-g.\n\\label{_auto8} \\tag{8}\n\\end{equation}\n$$\n\nHowever, we don't need find one with arbitrary constants. Hence, it is\ncalled a **particular** solution.\n\nThe sum of the two,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=v_{y,p}+v_{y,h},\n\\label{_auto9} \\tag{9}\n\\end{equation}\n$$\n\nis a solution of the total equation because of the linear nature of\nthe differential equation. One has now found a *general* solution\nencompassing all solutions, because it both satisfies the general\nequation (like the particular solution), and has an arbitrary constant\nthat can be adjusted to fit any initial condition (like the homogneous\nsolution). If the equation were not linear, e.g if there were a term\nsuch as $v_y^2$ or $v_y\\dot{v}_y$, this technique would not work.\n\n\n## More details\n\nReturning to the example above, the homogenous solution is the same as\nthat for $v_x$, because there was no gravitational acceleration in\nthat case,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,h}=Be^{-\\gamma t}.\n\\label{_auto10} \\tag{10}\n\\end{equation}\n$$\n\nIn this case a particular solution is one with constant velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{y,p}=-g/\\gamma.\n\\label{_auto11} \\tag{11}\n\\end{equation}\n$$\n\nNote that this is the terminal velocity of a particle falling from a\ngreat height. The general solution is thus,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=Be^{-\\gamma t}-g/\\gamma,\n\\label{_auto12} \\tag{12}\n\\end{equation}\n$$\n\nand one can find $B$ from the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_{0y}=B-g/\\gamma,~~~B=v_{0y}+g/\\gamma.\n\\label{_auto13} \\tag{13}\n\\end{equation}\n$$\n\nPlugging in the expression for $B$ gives the $y$ motion given the initial velocity,\n\n\n
\n\n$$\n\\begin{equation}\nv_y=(v_{0y}+g/\\gamma)e^{-\\gamma t}-g/\\gamma.\n\\label{_auto14} \\tag{14}\n\\end{equation}\n$$\n\nIt is easy to see that this solution has $v_y=v_{0y}$ when $t=0$ and\n$v_y=-g/\\gamma$ when $t\\rightarrow\\infty$.\n\nOne can also integrate the two equations to find the coordinates $x$\nand $y$ as functions of $t$,\n\n$$\n\\begin{eqnarray}\nx&=&\\int_0^t dt'~v_{0x}(t')=\\frac{v_{0x}}{\\gamma}\\left(1-e^{-\\gamma t}\\right),\\\\\n\\nonumber\ny&=&\\int_0^t dt'~v_{0y}(t')=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\end{eqnarray}\n$$\n\nIf the question was to find the position at a time $t$, we would be\nfinished. However, the more common goal in a projectile equation\nproblem is to find the range, i.e. the distance $x$ at which $y$\nreturns to zero. For the case without a drag force this was much\nsimpler. The solution for the $y$ coordinate would have been\n$y=v_{0y}t-gt^2/2$. One would solve for $t$ to make $y=0$, which would\nbe $t=2v_{0y}/g$, then plug that value for $t$ into $x=v_{0x}t$ to\nfind $x=2v_{0x}v_{0y}/g=v_0\\sin(2\\theta_0)/g$. One follows the same\nsteps here, except that the expression for $y(t)$ is more\ncomplicated. Searching for the time where $y=0$, and we get\n\n\n
\n\n$$\n\\begin{equation}\n0=-\\frac{gt}{\\gamma}+\\frac{v_{0y}+g/\\gamma}{\\gamma}\\left(1-e^{-\\gamma t}\\right).\n\\label{_auto15} \\tag{15}\n\\end{equation}\n$$\n\nThis cannot be inverted into a simple expression $t=\\cdots$. Such\nexpressions are known as \"transcendental equations\", and are not the\nrare instance, but are the norm. In the days before computers, one\nmight plot the right-hand side of the above graphically as\na function of time, then find the point where it crosses zero.\n\nNow, the most common way to solve for an equation of the above type\nwould be to apply Newton's method numerically. This involves the\nfollowing algorithm for finding solutions of some equation $F(t)=0$.\n\n1. First guess a value for the time, $t_{\\rm guess}$.\n\n2. Calculate $F$ and its derivative, $F(t_{\\rm guess})$ and $F'(t_{\\rm guess})$. \n\n3. Unless you guessed perfectly, $F\\ne 0$, and assuming that $\\Delta F\\approx F'\\Delta t$, one would choose \n\n4. $\\Delta t=-F(t_{\\rm guess})/F'(t_{\\rm guess})$.\n\n5. Now repeat step 1, but with $t_{\\rm guess}\\rightarrow t_{\\rm guess}+\\Delta t$.\n\nIf the $F(t)$ were perfectly linear in $t$, one would find $t$ in one\nstep. Instead, one typically finds a value of $t$ that is closer to\nthe final answer than $t_{\\rm guess}$. One breaks the loop once one\nfinds $F$ within some acceptable tolerance of zero. A program to do\nthis will be added shortly.\n\n\n## Motion in a Magnetic Field\n\n\nAnother example of a velocity-dependent force is magnetism,\n\n$$\n\\begin{eqnarray}\n\\boldsymbol{F}&=&q\\boldsymbol{v}\\times\\boldsymbol{B},\\\\\n\\nonumber\nF_i&=&q\\sum_{jk}\\epsilon_{ijk}v_jB_k.\n\\end{eqnarray}\n$$\n\nFor a uniform field in the $z$ direction $\\boldsymbol{B}=B\\hat{z}$, the force can only have $x$ and $y$ components,\n\n$$\n\\begin{eqnarray}\nF_x&=&qBv_y\\\\\n\\nonumber\nF_y&=&-qBv_x.\n\\end{eqnarray}\n$$\n\nThe differential equations are\n\n$$\n\\begin{eqnarray}\n\\dot{v}_x&=&\\omega_c v_y,\\omega_c= qB/m\\\\\n\\nonumber\n\\dot{v}_y&=&-\\omega_c v_x.\n\\end{eqnarray}\n$$\n\nOne can solve the equations by taking time derivatives of either equation, then substituting into the other equation,\n\n$$\n\\begin{eqnarray}\n\\ddot{v}_x=\\omega_c\\dot{v_y}=-\\omega_c^2v_x,\\\\\n\\nonumber\n\\ddot{v}_y&=&-\\omega_c\\dot{v}_x=-\\omega_cv_y.\n\\end{eqnarray}\n$$\n\nThe solution to these equations can be seen by inspection,\n\n$$\n\\begin{eqnarray}\nv_x&=&A\\sin(\\omega_ct+\\phi),\\\\\n\\nonumber\nv_y&=&A\\cos(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nOne can integrate the equations to find the positions as a function of time,\n\n$$\n\\begin{eqnarray}\nx-x_0&=&\\int_{x_0}^x dx=\\int_0^t dt v(t)\\\\\n\\nonumber\n&=&\\frac{-A}{\\omega_c}\\cos(\\omega_ct+\\phi),\\\\\n\\nonumber\ny-y_0&=&\\frac{A}{\\omega_c}\\sin(\\omega_ct+\\phi).\n\\end{eqnarray}\n$$\n\nThe trajectory is a circle centered at $x_0,y_0$ with amplitude $A$ rotating in the clockwise direction.\n\nThe equations of motion for the $z$ motion are\n\n\n
\n\n$$\n\\begin{equation}\n\\dot{v_z}=0,\n\\label{_auto16} \\tag{16}\n\\end{equation}\n$$\n\nwhich leads to\n\n\n
\n\n$$\n\\begin{equation}\nz-z_0=V_zt.\n\\label{_auto17} \\tag{17}\n\\end{equation}\n$$\n\nAdded onto the circle, the motion is helical.\n\nNote that the kinetic energy,\n\n\n
\n\n$$\n\\begin{equation}\nT=\\frac{1}{2}m(v_x^2+v_y^2+v_z^2)=\\frac{1}{2}m(\\omega_c^2A^2+V_z^2),\n\\label{_auto18} \\tag{18}\n\\end{equation}\n$$\n\nis constant. This is because the force is perpendicular to the\nvelocity, so that in any differential time element $dt$ the work done\non the particle $\\boldsymbol{F}\\cdot{dr}=dt\\boldsymbol{F}\\cdot{v}=0$.\n\nOne should think about the implications of a velocity dependent\nforce. Suppose one had a constant magnetic field in deep space. If a\nparticle came through with velocity $v_0$, it would undergo cyclotron\nmotion with radius $R=v_0/\\omega_c$. However, if it were still its\nmotion would remain fixed. Now, suppose an observer looked at the\nparticle in one reference frame where the particle was moving, then\nchanged their velocity so that the particle's velocity appeared to be\nzero. The motion would change from circular to fixed. Is this\npossible?\n\nThe solution to the puzzle above relies on understanding\nrelativity. Imagine that the first observer believes $\\boldsymbol{B}\\ne 0$ and\nthat the electric field $\\boldsymbol{E}=0$. If the observer then changes\nreference frames by accelerating to a velocity $\\boldsymbol{v}$, in the new\nframe $\\boldsymbol{B}$ and $\\boldsymbol{E}$ both change. If the observer moved to the\nframe where the charge, originally moving with a small velocity $v$,\nis now at rest, the new electric field is indeed $\\boldsymbol{v}\\times\\boldsymbol{B}$,\nwhich then leads to the same acceleration as one had before. If the\nvelocity is not small compared to the speed of light, additional\n$\\gamma$ factors come into play,\n$\\gamma=1/\\sqrt{1-(v/c)^2}$. Relativistic motion will not be\nconsidered in this course.\n\n\n\n\n## Sliding Block tied to a Wall\n\nAnother classical case is that of simple harmonic oscillations, here represented by a block sliding on a horizontal frictionless surface. The block is tied to a wall with a spring. If the spring is not compressed or stretched too far, the force on the block at a given position $x$ is\n\n$$\nF=-kx.\n$$\n\nThe negative sign means that the force acts to restore the object to an equilibrium position. Newton's equation of motion for this idealized system is then\n\n$$\nm\\frac{d^2x}{dt^2}=-kx,\n$$\n\nor we could rephrase it as\n\n\n
\n\n$$\n\\frac{d^2x}{dt^2}=-\\frac{k}{m}x=-\\omega_0^2x,\n\\label{eq:newton1} \\tag{19}\n$$\n\nwith the angular frequency $\\omega_0^2=k/m$. \n\nThe above differential equation has the advantage that it can be solved analytically with solutions on the form\n\n$$\nx(t)=Acos(\\omega_0t+\\nu),\n$$\n\nwhere $A$ is the amplitude and $\\nu$ the phase constant. This provides in turn an important test for the numerical\nsolution and the development of a program for more complicated cases which cannot be solved analytically. \n\n\nWith the position $x(t)$ and the velocity $v(t)=dx/dt$ we can reformulate Newton's equation in the following way\n\n$$\n\\frac{dx(t)}{dt}=v(t),\n$$\n\nand\n\n$$\n\\frac{dv(t)}{dt}=-\\omega_0^2x(t).\n$$\n\nWe are now going to solve these equations using first the standard forward Euler method. Later we will try to improve upon this.\n\n\nBefore proceeding however, it is important to note that in addition to the exact solution, we have at least two further tests which can be used to check our solution. \n\nSince functions like $cos$ are periodic with a period $2\\pi$, then the solution $x(t)$ has also to be periodic. This means that\n\n$$\nx(t+T)=x(t),\n$$\n\nwith $T$ the period defined as\n\n$$\nT=\\frac{2\\pi}{\\omega_0}=\\frac{2\\pi}{\\sqrt{k/m}}.\n$$\n\nObserve that $T$ depends only on $k/m$ and not on the amplitude of the solution. \n\n\nIn addition to the periodicity test, the total energy has also to be conserved. \n\nSuppose we choose the initial conditions\n\n$$\nx(t=0)=1\\hspace{0.1cm} \\mathrm{m}\\hspace{1cm} v(t=0)=0\\hspace{0.1cm}\\mathrm{m/s},\n$$\n\nmeaning that block is at rest at $t=0$ but with a potential energy\n\n$$\nE_0=\\frac{1}{2}kx(t=0)^2=\\frac{1}{2}k.\n$$\n\nThe total energy at any time $t$ has however to be conserved, meaning that our solution has to fulfil the condition\n\n$$\nE_0=\\frac{1}{2}kx(t)^2+\\frac{1}{2}mv(t)^2.\n$$\n\nWe will derive this equation in our discussion on [energy conservation](https://mhjensen.github.io/Physics321/doc/pub/energyconserv/html/energyconserv.html).\n\n\nAn algorithm which implements these equations is included below.\n * Choose the initial position and speed, with the most common choice $v(t=0)=0$ and some fixed value for the position. \n\n * Choose the method you wish to employ in solving the problem.\n\n * Subdivide the time interval $[t_i,t_f] $ into a grid with step size\n\n$$\nh=\\frac{t_f-t_i}{N},\n$$\n\nwhere $N$ is the number of mesh points. \n * Calculate now the total energy given by\n\n$$\nE_0=\\frac{1}{2}kx(t=0)^2=\\frac{1}{2}k.\n$$\n\n* Choose ODE solver to obtain $x_{i+1}$ and $v_{i+1}$ starting from the previous values $x_i$ and $v_i$.\n\n * When we have computed $x(v)_{i+1}$ we upgrade $t_{i+1}=t_i+h$.\n\n * This iterative process continues till we reach the maximum time $t_f$.\n\n * The results are checked against the exact solution. Furthermore, one has to check the stability of the numerical solution against the chosen number of mesh points $N$. \n\nThe following python program ( code will be added shortly)\n\n\n```\n#\n# This program solves Newtons equation for a block sliding on\n# an horizontal frictionless surface.\n# The block is tied to the wall with a spring, so N's eq takes the form:\n#\n# m d^2x/dt^2 = - kx\n#\n# In order to make the solution dimless, we set k/m = 1.\n# This results in two coupled diff. eq's that may be written as:\n#\n# dx/dt = v\n# dv/dt = -x\n#\n# The user has to specify the initial velocity and position,\n# and the number of steps. The time interval is fixed to\n# t \\in [0, 4\\pi) (two periods)\n#\n```\n\n## The classical pendulum and scaling the equations\n\nThe angular equation of motion of the pendulum is given by\nNewton's equation and with no external force it reads\n\n\n
\n\n$$\n\\begin{equation}\n ml\\frac{d^2\\theta}{dt^2}+mgsin(\\theta)=0,\n\\label{_auto19} \\tag{20}\n\\end{equation}\n$$\n\nwith an angular velocity and acceleration given by\n\n\n
\n\n$$\n\\begin{equation}\n v=l\\frac{d\\theta}{dt},\n\\label{_auto20} \\tag{21}\n\\end{equation}\n$$\n\nand\n\n\n
\n\n$$\n\\begin{equation}\n a=l\\frac{d^2\\theta}{dt^2}.\n\\label{_auto21} \\tag{22}\n\\end{equation}\n$$\n\n## More on the Pendulum\n\nWe do however expect that the motion will gradually come to an end due a viscous drag torque acting on the pendulum. \nIn the presence of the drag, the above equation becomes\n\n\n
\n\n$$\n\\begin{equation}\n ml\\frac{d^2\\theta}{dt^2}+\\nu\\frac{d\\theta}{dt} +mgsin(\\theta)=0, \\label{eq:pend1} \\tag{23}\n\\end{equation}\n$$\n\nwhere $\\nu$ is now a positive constant parameterizing the viscosity\nof the medium in question. In order to maintain the motion against\nviscosity, it is necessary to add some external driving force. \nWe choose here a periodic driving force. The last equation becomes then\n\n\n
\n\n$$\n\\begin{equation}\n ml\\frac{d^2\\theta}{dt^2}+\\nu\\frac{d\\theta}{dt} +mgsin(\\theta)=Asin(\\omega t), \\label{eq:pend2} \\tag{24}\n\\end{equation}\n$$\n\nwith $A$ and $\\omega$ two constants representing the amplitude and \nthe angular frequency respectively. The latter is called the driving frequency.\n\n\n\n\n## More on the Pendulum\n\nWe define\n\n$$\n\\omega_0=\\sqrt{g/l},\n$$\n\nthe so-called natural frequency and the new dimensionless quantities\n\n$$\n\\hat{t}=\\omega_0t,\n$$\n\nwith the dimensionless driving frequency\n\n$$\n\\hat{\\omega}=\\frac{\\omega}{\\omega_0},\n$$\n\nand introducing the quantity $Q$, called the *quality factor*,\n\n$$\nQ=\\frac{mg}{\\omega_0\\nu},\n$$\n\nand the dimensionless amplitude\n\n$$\n\\hat{A}=\\frac{A}{mg}\n$$\n\nWe have\n\n$$\n\\frac{d^2\\theta}{d\\hat{t}^2}+\\frac{1}{Q}\\frac{d\\theta}{d\\hat{t}} \n +sin(\\theta)=\\hat{A}cos(\\hat{\\omega}\\hat{t}).\n$$\n\nThis equation can in turn be recast in terms of two coupled first-order differential equations as follows\n\n$$\n\\frac{d\\theta}{d\\hat{t}}=\\hat{v},\n$$\n\nand\n\n$$\n\\frac{d\\hat{v}}{d\\hat{t}}=-\\frac{\\hat{v}}{Q}-sin(\\theta)+\\hat{A}cos(\\hat{\\omega}\\hat{t}).\n$$\n\nThese are the equations to be solved. The factor $Q$ represents the number of oscillations of the undriven system that must occur before its energy is significantly reduced due to the viscous drag. The amplitude $\\hat{A}$ is measured in units of the maximum possible gravitational torque while $\\hat{\\omega}$ is the angular frequency of the external torque measured in units of the pendulum's natural frequency.\n", "meta": {"hexsha": "8eb37a977444462cd35d691010f93d9c660da571", "size": 52676, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/forces/ipynb/forces.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2020-01-09T17:41:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T00:48:58.000Z", "max_issues_repo_path": "doc/pub/forces/ipynb/forces.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-08T03:47:53.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-15T15:02:57.000Z", "max_forks_repo_path": "doc/pub/forces/ipynb/forces.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2020-01-10T20:40:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T20:28:41.000Z", "avg_line_length": 31.6943441637, "max_line_length": 424, "alphanum_fraction": 0.5804540967, "converted": true, "num_tokens": 9428, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.34158251284363395, "lm_q2_score": 0.3276682876897044, "lm_q1q2_score": 0.11192575708822}}
{"text": "\n*This notebook contains material from [CBE40455-2020](https://jckantor.github.io/CBE40455-2020);\ncontent is available [on Github](https://github.com/jckantor/CBE40455-2020.git).*\n\n\n\n< [3.9 Refinements of a Grocery Store Checkout Operation](https://jckantor.github.io/CBE40455-2020/03.09-Refinements-to-the-Grocery-Store-Checkout-Operation.html) | [Contents](toc.html) | [3.11 Batch Chemical Process](https://jckantor.github.io/CBE40455-2020/03.11-Project-Batch-Chemical-Process.html) >
\n\n# 3.10 Objected-Oriented Simulation\n\nUp to this point we have been using Python generators and shared resources as the building blocks for simulations of complex systems. This can be effective, particularly if the individual agents do not require access to the internal state of other agents. But there are situations where the action of an agent depends on the state or properties of another agent in the simulation. For example, consider this discussion question from the Grocery store checkout example:\n\n>Suppose we were to change one or more of the lanes to a express lanes which handle only with a small number of items, say five or fewer. How would you expect this to change average waiting time? This is a form of prioritization ... are there other prioritizations that you might consider?\n\nThe customer action depends the item limit parameter associated with a checkout lane. This is a case where the action of one agent depends on a property of another. The shared resources builtin to the SimPy library provide some functionality in this regard, but how do add this to the simulations we write?\n\nThe good news is that Python offers a rich array of object oriented programming features well suited to this purpose. The SymPy documentation provides excellent examples of how to create Python objects for use in SymPy. The bad news is that object oriented programming in Python -- while straightforward compared to many other programming languages -- constitutes a steep learning curve for students unfamiliar with the core concepts.\n\nFortunately, since the introduction of Python 3.7 in 2018, the standard libraries for Python have included a simplified method for creating and using Python classes. Using [dataclass](https://realpython.com/python-data-classes/), it easy to create objects for SymPy simulations that retain the benefits of object oriented programming without all of the coding overhead. \n\nThe purpose of this notebook is to introduce the use of `dataclass` in creating SymPy simulations. To the best of the author's knowledge, this is a novel use of `dataclass` and the only example of which the author is aware.\n\n## 3.10.1 Installations and imports\n\n\n```python\n!pip install sympy\n```\n\n Requirement already satisfied: sympy in /Users/jeff/opt/anaconda3/lib/python3.7/site-packages (1.5.1)\n Requirement already satisfied: mpmath>=0.19 in /Users/jeff/opt/anaconda3/lib/python3.7/site-packages (from sympy) (1.1.0)\n\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport random\nimport simpy\nimport pandas as pd\nfrom dataclasses import dataclass\n```\n\n\n```python\nimport sys\nprint(sys.version)\n```\n\n 3.7.4 (default, Aug 13 2019, 15:17:50) \n [Clang 4.0.1 (tags/RELEASE_401/final)]\n\n\nAdditional imports are from the `dataclasses` library that has been part of the standard Python distribution since version 3.7. Here we import `dataclass` and `field`.\n\n\n```python\nfrom dataclasses import dataclass, field\n```\n\n## 3.10.2 Introduction to `dataclass`\n\nTutorials and additional documentation:\n\n* [The Ultimate Guide to Data Classes in Python 3.7](https://realpython.com/python-data-classes/): Tutorial article from ReaalPython.com\n* [dataclasses — Data Classes](https://docs.python.org/3/library/dataclasses.html): Official Python documentation.\n* [Data Classes in Python](https://towardsdatascience.com/data-classes-in-python-8d1a09c1294b): Tutorial from TowardsDataScience.com\n\n### 3.10.2.1 Creating a `dataclass`\n\nA `dataclass` defines a new class of Python objects. A `dataclass` object takes care of several routine things that you would otherwise have to code, such as creating instances of an object, testing for equality, and other aspects. \n\nAs an example, the following cell shows how to define a dataclass corresponding to a hypothetical Student object. The Student object maintains data associated with instances of a student. The dataclass also defines a function associated with the object.\n\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass Student():\n name: str\n graduation_class: int\n dorm: str\n \n def print_name(self):\n print(f\"{self.name} (Class of {self.graduation_class})\")\n```\n\nLet's create an instance of the Student object.\n\n\n```python\nsam = Student(\"Sam Jones\", 2024, \"Alumni\")\n```\n\nLet's see how the `print_name()` function works.\n\n\n```python\nsam.print_name()\n```\n\n Sam Jones (Class of 2024)\n\n\nThe next cell shows how to create a list of students, and how to iterate over a list of students.\n\n\n```python\n# create a list of students\nstudents = [\n Student(\"Sam Jones\", 2024, \"Alumni\"),\n Student(\"Becky Smith\", 2023, \"Howard\"),\n]\n\n# iterate over the list of students to print all of their names\nfor student in students:\n student.print_name()\n print(student.dorm)\n```\n\n Sam Jones (Class of 2024)\n Alumni\n Becky Smith (Class of 2023)\n Howard\n\n\nHere are a few details you need to use `dataclass` effectively:\n\n* The `class` statement is standard statement for creating a new class of Python objects. The preceding `@dataclass` is a Python 'decorator'. Decorators are Python functions that modify the behavior of subsequent statements. In this case, the `@dataclass` decorator modifies `class` to provide a streamlined syntax for implementing classes.\n* A Python class names begin with a capital letter. In this case `Student` is the class name.\n* The lines following the the class statement declare parameters that will be used by the new class. The parameters can be specified when you create an instance of the dataclass. \n* Each paraameter is followed by type 'hint'. Commonly used type hints are `int`, `float`, `bool`, and `str`. Use the keyword `any` you don't know or can't specify a particular type. Type hints are actually used by type-checking tools and ignored by the python interpreter.\n* Following the parameters, write any functions or generators that you may wish to define for the new class. To access variables unique to an instance of the class, preceed the parameter name with `self`.\n\n### 3.10.2.2 Specifying parameter values\n\nThere are different ways of specifying the parameter values assigned to an instance of a dataclass. Here are three particular methods:\n\n* Specify the parameter value when creating a new instance. This is what was done in the Student example above.\n* Provide a default values determined when the dataclass is defined.\n* Provide a default_factory method to create a parameter value when an instance of the dataclass is created.\n\n#### 3.10.2.2.1 Specifying a parameter value when creating a new instance\n\nParameter values can be specified when creating an instance of a dataclass. The parameter values can be specified by position or by name as shown below.\n\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass Student():\n name: str\n graduation_year: int\n dorm: str\n \n def print_name(self):\n print(f\"{self.name} (Class of {self.graduation_year})\")\n \nsam = Student(\"Sam Jones\", 2031, \"Alumni\")\nsam.print_name()\n\ngilda = Student(name=\"Gilda Radner\", graduation_year=2030, dorm=\"Howard\")\ngilda.print_name()\n```\n\n Sam Jones (Class of 2031)\n Gilda Radner (Class of 2030)\n\n\n#### 3.10.2.2.2 Setting default parameter values\n\nSetting a default value for a parameter can save extra typing or coding. More importantly, setting default values makes it easier to maintain and adapt code for other applications, and is a convenient way to handle missing data. \n\nThere are two ways to set default parameter values. For str, int, float, bool, tuple (the immutable types in Python), a default value can be set using `=` as shown in the next cell.\n\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass Student():\n name: str = None\n graduation_year: int = None\n dorm: str = None\n \n def print_name(self):\n print(f\"{self.name} (Class of {self.graduation_year})\")\n \njdoe = Student(name=\"John Doe\", dorm=\"Alumni\")\njdoe.print_name()\n```\n\n John Doe (Class of None)\n\n\nDefault parameter values are restricted to 'immutable' types. This technical restriction eliminiates the error-prone practice of use mutable objects, such as lists, as defaults. The difficulty with setting defaults for mutable objects is that all instances of the dataclass share the same value. If one instance of the object changes that value, then all other instances are affected. This leads to unpredictable behavior, and is a particularly nasty bug to uncover and fix.\n\nThere are two ways to provide defaults for mutable parameters such as lists, sets, dictionaries, or arbitrary Python objects. \n\nThe more direct way is to specify a function for constucting the default parameter value using the `field` statement with the `default_factory` option. The default_factory is called when a new instance of the dataclass is created. The function must take no arguments and must return a value that will be assigned to the designated parameter. Here's an example.\n\n\n```python\nfrom dataclasses import dataclass\n\n@dataclass\nclass Student():\n name: str = None\n graduation_year: int = None\n dorm: str = None\n majors: list = field(default_factory=list)\n \n def print_name(self):\n print(f\"{self.name} (Class of {self.graduation_year})\")\n \n def print_majors(self):\n for n, major in enumerate(self.majors):\n print(f\" {n+1}. {major}\")\n \njdoe = Student(name=\"John Doe\", dorm=\"Alumni\", majors=[\"Math\", \"Chemical Engineering\"])\njdoe.print_name()\njdoe.print_majors()\n\nStudent().print_majors()\n```\n\n John Doe (Class of None)\n 1. Math\n 2. Chemical Engineering\n\n\n#### 3.10.2.2.3 Initializing a dataclass with __post_init__(self)\n\nFrequently there are additional steps to complete when creating a new instance of a dataclass. For that purpose, a dataclass may contain an\noptional function with the special name `__post_init__(self)`. If present, that function is run automatically following the creation of a new instance. This feature will be demonstrated in following reimplementation of the grocery store checkout operation.\n\n## 3.10.3 Using `dataclass` with Simpy\n\n### 3.10.3.1 Step 0. A simple model\n\nTo demonstrate the use of classes in SimPy simulations, let's begin with a simple model of a clock using generators.\n\n\n```python\nimport simpy\n\ndef clock(id=\"\", t_step=1.0):\n while True:\n print(id, env.now)\n yield env.timeout(t_step)\n \nenv = simpy.Environment()\nenv.process(clock(\"A\"))\nenv.process(clock(\"B\", 1.5))\nenv.run(until=5.0)\n```\n\n A 0\n B 0\n A 1.0\n B 1.5\n A 2.0\n B 3.0\n A 3.0\n A 4.0\n B 4.5\n\n\n### 3.10.3.2 Step 1. Embed the generator inside of a class\n\nAs a first step, we rewrite the generator as a Python dataclass named `Clock`. The parameters are given default values, and the generator is incorporated within the Clock object. Note the use of `self` to refer to parameters specific to an instance of the class.\n\n\n```python\nimport simpy\nfrom dataclasses import dataclass\n\n@dataclass\nclass Clock():\n id: str = \"\"\n t_step: float = 1.0\n \n def process(self):\n while True:\n print(self.id, env.now)\n yield env.timeout(self.t_step)\n\nenv = simpy.Environment()\nenv.process(Clock(\"A\").process())\nenv.process(Clock(\"B\", 1.5).process())\nenv.run(until=5)\n```\n\n A 0\n B 0\n A 1.0\n B 1.5\n A 2.0\n B 3.0\n A 3.0\n A 4.0\n B 4.5\n\n\n### 3.10.3.3 Step 2. Eliminate (if possible) global variables\n\nOur definition of clock requires the simulation environment to have a specific name `env`, and assumes env is a global variable. That's generally not a good coding practice because it imposes an assumption on any user of the class, and exposes the internal coding of the class. A much better practice is to use class parameters to pass this data through a well defined interface to the class.\n\n\n```python\nimport simpy\nfrom dataclasses import dataclass\n\n@dataclass\nclass Clock():\n env: simpy.Environment\n id: str = \"\"\n t_step: float = 1.0\n \n def process(self):\n while True:\n print(self.id, self.env.now)\n yield self.env.timeout(self.t_step)\n\nenv = simpy.Environment()\nenv.process(Clock(env, \"A\").process())\nenv.process(Clock(env, \"B\", 1.5).process())\nenv.run(until=10)\n```\n\n A 0\n B 0\n A 1.0\n B 1.5\n A 2.0\n B 3.0\n A 3.0\n A 4.0\n B 4.5\n A 5.0\n B 6.0\n A 6.0\n A 7.0\n B 7.5\n A 8.0\n B 9.0\n A 9.0\n\n\n### 3.10.3.4 Step 3. Encapsulate initializations inside __post_init__\n\n\n```python\nimport simpy\nfrom dataclasses import dataclass\n\n@dataclass\nclass Clock():\n env: simpy.Environment\n id: str = \"\"\n t_step: float = 1.0\n \n def __post_init__(self):\n self.env.process(self.process())\n \n def process(self):\n while True:\n print(self.id, self.env.now)\n yield self.env.timeout(self.t_step)\n\nenv = simpy.Environment()\nClock(env, \"A\")\nClock(env, \"B\", 1.5)\nenv.run(until=5)\n```\n\n A 0\n B 0\n A 1.0\n B 1.5\n A 2.0\n B 3.0\n A 3.0\n A 4.0\n B 4.5\n\n\n## 3.10.4 Grocery Store Model\n\nLet's review our model for the grocery store checkout operations. There are multiple checkout lanes, each with potentially different characteristics. With generators we were able to implement differences in the time required to scan items. But another parameter, a limit on number of items that could be checked out in a lane, required a new global list. The reason was the need to access that parameter, something that a generator doesn't allow. This is where classes become important building blocks in creating more complex simulations.\n\nOur new strategy will be encapsulate the generator inside of a dataclass object. Here's what we'll ask each class definition to do:\n\n* Create a parameter corresponding to the simulation environment. This makes our classes reusable in other simulations by eliminating a reference to a globall variable.\n* Create parameters with reasonable defaults values.\n* Initialize any objects used within the class.\n* Register the class generator with the simulation environment.\n\n\n\n```python\nfrom dataclasses import dataclass\n\n# create simulation models\n@dataclass\nclass Checkout():\n env: simpy.Environment\n lane: simpy.Store = None\n t_item: float = 1/10\n item_limit: int = 25\n t_payment: float = 2.0\n \n def __post_init__(self):\n self.lane = simpy.Store(self.env)\n self.env.process(self.process())\n \n def process(self):\n while True:\n customer_id, cart, enter_time = yield self.lane.get()\n wait_time = env.now - enter_time\n yield env.timeout(self.t_payment + cart*self.t_item)\n customer_log.append([customer_id, cart, enter_time, wait_time, env.now]) \n \n@dataclass\nclass CustomerGenerator():\n env: simpy.Environment\n rate: float = 1.0\n customer_id: int = 1\n \n def __post_init__(self):\n self.env.process(self.process())\n \n def process(self):\n while True:\n yield env.timeout(random.expovariate(self.rate))\n cart = random.randint(1, 25)\n available_checkouts = [checkout for checkout in checkouts if cart <= checkout.item_limit]\n checkout = min(available_checkouts, key=lambda checkout: len(checkout.lane.items))\n yield checkout.lane.put([self.customer_id, cart, env.now])\n self.customer_id += 1\n\ndef lane_logger(t_sample=0.1):\n while True:\n lane_log.append([env.now] + [len(checkout.lane.items) for checkout in checkouts])\n yield env.timeout(t_sample)\n \n# create simulation environment\nenv = simpy.Environment()\n\n# create simulation objects (agents)\nCustomerGenerator(env)\ncheckouts = [\n Checkout(env, t_item=1/5, item_limit=25),\n Checkout(env, t_item=1/5, item_limit=25),\n Checkout(env, item_limit=5),\n Checkout(env),\n Checkout(env),\n]\nenv.process(lane_logger())\n\n# run process\ncustomer_log = []\nlane_log = []\nenv.run(until=600)\n```\n\n\n```python\ndef visualize():\n\n # extract lane data\n lane_df = pd.DataFrame(lane_log, columns = [\"time\"] + [f\"lane {n}\" for n in range(0, len(checkouts))])\n lane_df = lane_df.set_index(\"time\")\n\n customer_df = pd.DataFrame(customer_log, columns = [\"customer id\", \"cart items\", \"enter\", \"wait\", \"leave\"])\n customer_df[\"elapsed\"] = customer_df[\"leave\"] - customer_df[\"enter\"]\n\n # compute kpi's\n print(f\"Average waiting time = {customer_df['wait'].mean():5.2f} minutes\")\n print(f\"\\nAverage lane queue \\n{lane_df.mean()}\")\n print(f\"\\nOverall aaverage lane queue \\n{lane_df.mean().mean():5.4f}\")\n\n # plot results\n fig, ax = plt.subplots(3, 1, figsize=(12, 7))\n ax[0].plot(lane_df)\n ax[0].set_xlabel(\"time / min\")\n ax[0].set_title(\"length of checkout lanes\")\n ax[0].legend(lane_df.columns)\n\n ax[1].bar(customer_df[\"customer id\"], customer_df[\"wait\"])\n ax[1].set_xlabel(\"customer id\")\n ax[1].set_ylabel(\"minutes\")\n ax[1].set_title(\"customer waiting time\")\n\n ax[2].bar(customer_df[\"customer id\"], customer_df[\"elapsed\"])\n ax[2].set_xlabel(\"customer id\")\n ax[2].set_ylabel(\"minutes\")\n ax[2].set_title(\"total elapsed time\")\n plt.tight_layout()\n \nvisualize()\n```\n\n## 3.10.5 Customers as agents\n\n\n```python\nfrom dataclasses import dataclass\n\n# create simulation models\n@dataclass\nclass Checkout():\n env: simpy.Environment\n lane: simpy.Store = None\n t_item: float = 1/10\n item_limit: int = 25\n t_payment: float = 2.0\n \n def __post_init__(self):\n self.lane = simpy.Store(self.env)\n self.env.process(self.process())\n \n def process(self):\n while True:\n customer_id, cart, enter_time = yield self.lane.get()\n wait_time = env.now - enter_time\n yield env.timeout(self.t_payment + cart*self.t_item)\n customer_log.append([customer_id, cart, enter_time, wait_time, env.now]) \n \n@dataclass\nclass CustomerGenerator():\n env: simpy.Environment\n rate: float = 1.0\n customer_id: int = 1\n \n def __post_init__(self):\n self.env.process(self.process())\n \n def process(self):\n while True:\n yield env.timeout(random.expovariate(self.rate))\n Customer(self.env, self.customer_id)\n self.customer_id += 1\n \n@dataclass\nclass Customer():\n env: simpy.Environment\n id: int = 0\n \n def __post_init__(self):\n self.cart = random.randint(1, 25)\n self.env.process(self.process())\n \n def process(self):\n available_checkouts = [checkout for checkout in checkouts if self.cart <= checkout.item_limit]\n checkout = min(available_checkouts, key=lambda checkout: len(checkout.lane.items))\n yield checkout.lane.put([self.id, self.cart, env.now])\n \n\ndef lane_logger(t_sample=0.1):\n while True:\n lane_log.append([env.now] + [len(checkout.lane.items) for checkout in checkouts])\n yield env.timeout(t_sample)\n \n# create simulation environment\nenv = simpy.Environment()\n\n# create simulation objects (agents)\nCustomerGenerator(env)\ncheckouts = [\n Checkout(env, t_item=1/5, item_limit=25),\n Checkout(env, t_item=1/5, item_limit=25),\n Checkout(env, item_limit=5),\n Checkout(env),\n Checkout(env),\n]\nenv.process(lane_logger())\n\n# run process\ncustomer_log = []\nlane_log = []\nenv.run(until=600)\n\nvisualize()\n```\n\n## 3.10.6 Creating Smart Objects\n\n\n```python\nfrom dataclasses import dataclass, field\nimport pandas as pd\n\n# create simulation models\n@dataclass\nclass Checkout():\n lane: simpy.Store\n t_item: float = 1/10\n item_limit: int = 25\n \n def process(self):\n while True:\n customer_id, cart, enter_time = yield self.lane.get()\n wait_time = env.now - enter_time\n yield env.timeout(t_payment + cart*self.t_item)\n customer_log.append([customer_id, cart, enter_time, wait_time, env.now]) \n \n@dataclass\nclass CustomerGenerator():\n rate: float = 1.0\n customer_id: int = 1\n \n def process(self):\n while True:\n yield env.timeout(random.expovariate(self.rate))\n cart = random.randint(1, 25)\n available_checkouts = [checkout for checkout in checkouts if cart <= checkout.item_limit]\n checkout = min(available_checkouts, key=lambda checkout: len(checkout.lane.items))\n yield checkout.lane.put([self.customer_id, cart, env.now])\n self.customer_id += 1\n\n@dataclass\nclass LaneLogger():\n lane_log: list = field(default_factory=list) # this creates a variable that can be modified\n t_sample: float = 0.1\n lane_df: pd.DataFrame = field(default_factory=pd.DataFrame)\n \n def process(self):\n while True:\n self.lane_log.append([env.now] + [len(checkout.lane.items) for checkout in checkouts])\n yield env.timeout(self.t_sample)\n \n def report(self):\n self.lane_df = pd.DataFrame(self.lane_log, columns = [\"time\"] + [f\"lane {n}\" for n in range(0, N)])\n self.lane_df = self.lane_df.set_index(\"time\")\n print(f\"\\nAverage lane queue \\n{self.lane_df.mean()}\")\n print(f\"\\nOverall average lane queue \\n{self.lane_df.mean().mean():5.4f}\")\n \n def plot(self):\n self.lane_df = pd.DataFrame(self.lane_log, columns = [\"time\"] + [f\"lane {n}\" for n in range(0, N)])\n self.lane_df = self.lane_df.set_index(\"time\") \n fig, ax = plt.subplots(1, 1, figsize=(12, 3))\n ax.plot(self.lane_df)\n ax.set_xlabel(\"time / min\")\n ax.set_title(\"length of checkout lanes\")\n ax.legend(self.lane_df.columns) \n \n# create simulation environment\nenv = simpy.Environment()\n\n# create simulation objects (agents)\ncustomer_generator = CustomerGenerator()\ncheckouts = [\n Checkout(simpy.Store(env), t_item=1/5),\n Checkout(simpy.Store(env), t_item=1/5),\n Checkout(simpy.Store(env), item_limit=5),\n Checkout(simpy.Store(env)),\n Checkout(simpy.Store(env)),\n]\nlane_logger = LaneLogger()\n\n# register agents\nenv.process(customer_generator.process())\nfor checkout in checkouts:\n env.process(checkout.process()) \nenv.process(lane_logger.process())\n\n# run process\nenv.run(until=600)\n\n# plot results\nlane_logger.report()\nlane_logger.plot()\n```\n\n\n```python\n\n```\n\n\n< [3.9 Refinements of a Grocery Store Checkout Operation](https://jckantor.github.io/CBE40455-2020/03.09-Refinements-to-the-Grocery-Store-Checkout-Operation.html) | [Contents](toc.html) | [3.11 Batch Chemical Process](https://jckantor.github.io/CBE40455-2020/03.11-Project-Batch-Chemical-Process.html) >
\n", "meta": {"hexsha": "2d18b826333fe9f03d5bf77485abbf18033577d7", "size": 267255, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/03.10-Creating-Simulation-Classes.ipynb", "max_stars_repo_name": "jckantor/CBE40455-2020", "max_stars_repo_head_hexsha": "318bd71b7259c6f2f810cc55f268e2477c6b8cfd", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2020-08-18T13:22:49.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-31T23:30:56.000Z", "max_issues_repo_path": "docs/03.10-Creating-Simulation-Classes.ipynb", "max_issues_repo_name": "jckantor/CBE40455-2020", "max_issues_repo_head_hexsha": "318bd71b7259c6f2f810cc55f268e2477c6b8cfd", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "docs/03.10-Creating-Simulation-Classes.ipynb", "max_forks_repo_name": "jckantor/CBE40455-2020", "max_forks_repo_head_hexsha": "318bd71b7259c6f2f810cc55f268e2477c6b8cfd", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2020-11-07T21:36:12.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-11T20:38:20.000Z", "avg_line_length": 202.0068027211, "max_line_length": 75216, "alphanum_fraction": 0.8989915998, "converted": true, "num_tokens": 5914, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3886180408675583, "lm_q2_score": 0.28776782186926264, "lm_q1q2_score": 0.11183176715955735}}
{"text": "# Introducción a Python\n\n## introducción\n\n[Python](https://www.python.org/) es un lenguaje de propósito general sencillo y expresivo. Permite acceder cómodamente a una amplia colección de bibliotecas útiles en todos los campos de la informática. Su uso en ciencia y tecnología es cada vez mayor.\n\nEs un lenguaje interpretado, con tipos de datos dinámicos y manejo automático de memoria, que puede utilizarse tanto para escribir programas de forma tradicional como para experimentar en un entorno interactivo. Incluye las construcciones más importantes de programación funcional y admite programación orientada a objetos.\n\nLa sintaxis es simple e intuitiva pero hay que tener en cuenta algunas características:\n\n\n- Los bloques de instrucciones de las construcciones condicionales, bucles y funciones se delimitan mediante la \"indentación del código\": no se utiliza \"end\" ni `{` `}`.\n\n- Los índices para acceder a los arrays o listas comienzan en 0 y acaban en tamaño-1. Las secuencias (*range*) usadas en bucles o *list comprehensions* no incluyen el límite superior.\n\n- Algunas funciones tienen la sintaxis tradicional `f(x)`, `g(x,a)`, mientras que otras se expresan como `x.f()`, `x.g(a)`, etc., indicando que el \"objeto\" `x` se modifica de alguna forma.\n\n- Los arrays y las listas son \"mutables\": su asignación a otra variable **no** crea una copia del objeto original sino una \"referencia\" a través de la cual se puede modificar la estructura original.\n\n- Las funciones pueden leer directamente el valor de variables globales, pero para modificarlas hay que declararlas como `global`. La asignación de variables dentro de una función crea variables locales.\n\n- La única forma de crear un ámbito de variables es definir una función. Los índices de los bucles son visibles a la salida.\n\n### instalación\n\n[Anaconda](https://www.continuum.io/DOWNLOADS)\n\nSi partimos de la instalación mínima [miniconda](https://conda.io/miniconda.html) necesitamos los siguiente paquetes:\n\n > conda install jupyter numpy scipy sympy matplotlib\n\nArrancamos el \"servidor\" de notebooks con\n\n > jupyter notebook\n\nLas celdas de código se evalúan pulsando Mayúsculas-Entrar.\n\n## tipos simples\n\nCadenas de caracteres:\n\n\n```python\ns = 'Hola' \n```\n\n\n```python\ns\n```\n\n\n\n\n 'Hola'\n\n\n\n\n```python\nprint(s)\n```\n\n Hola\n\n\n\n```python\ntype(s)\n```\n\n\n\n\n str\n\n\n\nSe admiten diferentes tipos de delimitadores y cadenas multilínea.\n\n\n```python\n\"Hola\" + ''' amigos!'''\n```\n\n\n\n\n 'Hola amigos!'\n\n\n\nVariables lógicas:\n\n\n```python\nc = 3 < 4\n```\n\n\n```python\ntype(c)\n```\n\n\n\n\n bool\n\n\n\n\n```python\nc and (2==1+1) or not (3 != 5)\n```\n\n\n\n\n True\n\n\n\nNúmeros reales aproximados con coma flotante de doble precisión:\n\n\n```python\nx = 3.5\n```\n\n\n```python\ntype(x)\n```\n\n\n\n\n float\n\n\n\nLos enteros tienen tamaño ilimitado:\n\n\n```python\nx = 20\n```\n\n\n```python\ntype(x)\n```\n\n\n\n\n int\n\n\n\n\n```python\nx**x\n```\n\n\n\n\n 104857600000000000000000000\n\n\n\nVariable compleja:\n\n\n```python\n(1+1j)*(1-1j)\n```\n\n\n\n\n (2+0j)\n\n\n\n\n```python\nimport cmath\n\ncmath.sqrt(-1)\n```\n\n\n\n\n 1j\n\n\n\n## control\n\nCondiciones:\n\n\n```python\nk = 7\n\nif k%2 == 0:\n print(k,\" es par\")\nelse:\n print(k,\" es impar\")\n print(\"me gustan los impares\")\n```\n\n 7 es impar\n me gustan los impares\n\n\nBucles:\n\n\n```python\nfor k in [1,2,3]:\n print(k)\n```\n\n 1\n 2\n 3\n\n\n\n```python\nfor k in range(5):\n print(k)\n```\n\n 0\n 1\n 2\n 3\n 4\n\n\n\n```python\nk = 1\np = 1\nwhile k < 5:\n p = p*k\n k = k+1\np\n```\n\n\n\n\n 24\n\n\n\n## contenedores\n\n### tuplas\n\n\n```python\nt = (2,'rojo')\n```\n\n\n```python\nt\n```\n\n\n\n\n (2, 'rojo')\n\n\n\n\n```python\nt[0]\n```\n\n\n\n\n 2\n\n\n\nSon inmutables.\n\n### listas\n\n\n```python\nl = [1,-2,67,0,8,1,3]\n```\n\n\n```python\ntype(l)\n```\n\n\n\n\n list\n\n\n\nTambién admite elementos de diferentes tipos, incluyendo otras listas, tuplas, o cualquier otro tipo de datos, aunque lo normal es trabajar con listas homogéneas (con elementos del mismo tipo) cuyos elementos pueden procesarse todos de la misma manera usando un bucle.\n\nLa extracción de elementos (\"indexado\"), la longitud de la lista y la suma de sus elementos se consiguen exactamente igual que en las tuplas:\n\n\n```python\nl[2], len(l), sum(l)\n```\n\n\n\n\n (67, 7, 78)\n\n\n\nSin embargo, las listas se diferencian en una característica fundamental. Son **mutables**: podemos añadir o quitar elementos de ellas.\n\n\n```python\nl.append(28)\n\nl\n```\n\n\n\n\n [1, -2, 67, 0, 8, 1, 3, 28]\n\n\n\n\n```python\nl += [-2,4]\n\nl\n```\n\n\n\n\n [1, -2, 67, 0, 8, 1, 3, 28, -2, 4]\n\n\n\n\n```python\nl.remove(0)\n\nl\n```\n\n\n\n\n [1, -2, 67, 8, 1, 3, 28, -2, 4]\n\n\n\n\n```python\nl[2] = 7\n\nl\n```\n\n\n\n\n [1, -2, 7, 8, 1, 3, 28, -2, 4]\n\n\n\n\n```python\nl.pop()\n```\n\n\n\n\n 4\n\n\n\n\n```python\nl\n```\n\n\n\n\n [1, -2, 7, 8, 1, 3, 28, -2]\n\n\n\n\n```python\ndel l[2]\n```\n\n\n```python\nl\n```\n\n\n\n\n [1, -2, 8, 1, 3, 28, -2]\n\n\n\n\n```python\nl.insert(3,100)\n\nl\n```\n\n\n\n\n [1, -2, 8, 100, 1, 3, 28, -2]\n\n\n\n### conjuntos\n\nEl tipo `set` trata de reproducir el concepto matemático de conjunto. Se construye con llaves y los elementos duplicados se eliminan automáticamente.\n\n\n```python\nC = {1,2,7,1,8,2,1}\nC\n```\n\n\n\n\n {1, 2, 7, 8}\n\n\n\nLas operaciones de conjuntos están disponibles con símbolos o con \"métodos\" (funciones en forma de sufijo) . Los detalles pueden encontrarse en la [documentación](https://docs.python.org/3.6/library/stdtypes.html?highlight=set#set).\n\n\n```python\nC.union({0,8})\n```\n\n\n\n\n {0, 1, 2, 7, 8}\n\n\n\n\n```python\nC | {0,8}\n```\n\n\n\n\n {0, 1, 2, 7, 8}\n\n\n\n\n```python\nC & {5,2}\n```\n\n\n\n\n {2}\n\n\n\n\n```python\nC - {2,8,0,5}\n```\n\n\n\n\n {1, 7}\n\n\n\n\n```python\n5 in C\n```\n\n\n\n\n False\n\n\n\n\n```python\n{1,2} < {5,2,1}\n```\n\n\n\n\n True\n\n\n\n### diccionarios\n\nEs un array asociativo (el índice puede ser cualquier tipo (inmutable)). Es una estructura muy utilizada en Python.\n\n\n```python\nd = {'lunes': 8, 'martes' : [1,2,3], 3: 5}\n```\n\n\n```python\nd['martes']\n```\n\n\n\n\n [1, 2, 3]\n\n\n\n\n```python\nd.keys()\n```\n\n\n\n\n dict_keys(['lunes', 'martes', 3])\n\n\n\n\n```python\nd.values()\n```\n\n\n\n\n dict_values([8, [1, 2, 3], 5])\n\n\n\n### iteración en contenedores\n\nSi queremos procesar todos los elementos de un contenedor podemos hacer un bucle y acceder a cada uno de ellos con la operación de indexado.\n\n\n```python\nlista = [1,2,3,4,5]\n\nfor k in range(len(lista)):\n print(lista[k])\n```\n\n 1\n 2\n 3\n 4\n 5\n\n\nEsta construcción es tan común que en Python podemos escribirla de forma mucho más natural:\n\n\n```python\nfor x in lista:\n print(x)\n```\n\n 1\n 2\n 3\n 4\n 5\n\n\nEsto funciona incluso en contenedores como `set` que no admiten el indexado. Los tipos contenedores se pueden \"recorrer\" directamente mediante un bucle `for`, visitando todos sus elementos.\n\n### conversión\n\nEl nombre de un contenedor es a la vez una función para construir un contenedor de ese tipo a partir de otro contenedor cualquiera.\n\n\n```python\nl = [4,2,2,3,3,3,3,1]\n\ntuple(l)\n```\n\n\n\n\n (4, 2, 2, 3, 3, 3, 3, 1)\n\n\n\n\n```python\nset(l)\n```\n\n\n\n\n {1, 2, 3, 4}\n\n\n\n\n```python\nlist({5,4,3})\n```\n\n\n\n\n [3, 4, 5]\n\n\n\n\n```python\nlist(range(10))\n```\n\n\n\n\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n\n\n\nEsta característica funciona con cualquier otro tipo, no solo con contenedores:\n\n\n```python\nfloat(5)\n```\n\n\n\n\n 5.0\n\n\n\n\n```python\nint('54')\n```\n\n\n\n\n 54\n\n\n\nSi la conversión no es posible se producirá un error.\n\n### subsecuencias\n\n\n```python\nl = list(range(20))\n\nl\n```\n\n\n\n\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n\n\n\n\n```python\nl[:5]\n```\n\n\n\n\n [0, 1, 2, 3, 4]\n\n\n\n\n```python\nl[4:]\n```\n\n\n\n\n [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n\n\n\n\n```python\nl[-3:]\n```\n\n\n\n\n [17, 18, 19]\n\n\n\n\n```python\nl[5:10:2]\n```\n\n\n\n\n [5, 7, 9]\n\n\n\n\n```python\nl[::-1]\n```\n\n\n\n\n [19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]\n\n\n\n\n```python\nl[10:14] = [0,0,0]\n\nl\n```\n\n\n\n\n [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 14, 15, 16, 17, 18, 19]\n\n\n\n### *list comprehensions*\n\nCuando utilizamos un bucle para recorrer una lista o realizar un gran número de cálculos los resultados intermedios se pueden imprimir si se desea, pero en cualquier caso al final se pierden.\n\nMuchas veces surge la necesidad de construir una lista (o cualquier otro tipo de contenedor) a partir de los elementos de otra. Una forma de programarlo es empezar con una lista vacía e iterar mediante un bucle añadiendo elementos.\n\nSupongamos que queremos construir una lista con los 100 primeros números cuadrados $1,4,9,16,\\ldots,10000$. En principio parece razonable hacer lo siguiente:\n\n\n```python\nr = []\nfor k in range(1,101):\n r.append(k**2)\n\nprint(r)\n```\n\n [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801, 10000]\n\n\nNo está mal, pero los lenguajes modernos proporcionan una herramienta mucho más elegante para expresar este tipo de cálculos. Se conoce como [list comprehension](https://en.wikipedia.org/wiki/List_comprehension) y trata de imitar la notación matemática para definir conjuntos:\n\n$$ r = \\{ k^2 \\; : \\; \\forall k \\in \\mathbb{N}, \\;1 \\leq k \\leq 100 \\} $$\n\n\n```python\nr = [ k**2 for k in range(1,101) ]\n\nprint(r)\n```\n\n [1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024, 1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936, 2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136, 3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624, 4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400, 6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464, 8649, 8836, 9025, 9216, 9409, 9604, 9801, 10000]\n\n\n\n```python\n[ k for k in range(100) if k%7 == 0 ]\n```\n\n\n\n\n [0, 7, 14, 21, 28, 35, 42, 49, 56, 63, 70, 77, 84, 91, 98]\n\n\n\n\n```python\n[(a,b) for a in range(1,7) for b in range(1,7) if a + b >= 10 ]\n```\n\n\n\n\n [(4, 6), (5, 5), (5, 6), (6, 4), (6, 5), (6, 6)]\n\n\n\n\n```python\n{ a+b for a in range(1,7) for b in range(1,7) }\n```\n\n\n\n\n {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}\n\n\n\n\n```python\nsum([k**2 for k in range(100+1)])\n```\n\n\n\n\n 338350\n\n\n\n### desestructuración\n\nEn Python es posible asignar nombres a los elementos de una secuencia de forma muy natural.\n\nSupongamos que tenemos una tupla como la siguiente\n\n\n```python\nt = (3,4,5)\n```\n\ny queremos operar con sus elementos. Podemos acceder con un índice:\n\n\n```python\nt[1] + t[2]\n```\n\n\n\n\n 9\n\n\n\nNo hay ningún problema pero el acceso con índice se hace pesado si los elementos aparecen varias veces en el código. En estos casos es mejor ponerles nombre. Podemos hacer\n\n\n```python\nb = t[1]\nc = t[2]\n\nb+c\n```\n\n\n\n\n 9\n\n\n\nSin embargo Python nos permite algo más elegante:\n\n\n```python\n_,b,c = t\n\nb+c\n```\n\n\n\n\n 9\n\n\n\n(El nombre `_` se suele usar cuando no necesitamos ese elemento.)\n\nUsando esta característica podemos escribir varias asignaciones de una vez:\n\n\n```python\nx,y = 23,45\n```\n\nUn nombre con asterisco captura dentro de una lista todos los elementos restantes:\n\n\n```python\ns = 'Alberto'\n\nx, y, *z, w = s\n```\n\n\n```python\ny\n```\n\n\n\n\n 'l'\n\n\n\n\n```python\nz\n```\n\n\n\n\n ['b', 'e', 'r', 't']\n\n\n\nLa desestructuración de argumentos es muy práctica en combinación con las *list comprehensions*:\n\n\n```python\nl = [(k,k**2) for k in range(5)]\nl\n```\n\n\n\n\n [(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]\n\n\n\n\n```python\n[a+b for a,b in l]\n```\n\n\n\n\n [0, 2, 6, 12, 20]\n\n\n\n## funciones\n\n\n```python\ndef sp(n):\n r = n**2+n+41\n return r\n```\n\n\n```python\nsp(5)\n```\n\n\n\n\n 71\n\n\n\nSe pueden devolver varios resultados en una tupla:\n\n\n```python\nimport math\n\ndef ecsec(a,b,c):\n d = math.sqrt(b**2- 4*a*c)\n s1 = (-b+d)/2/a\n s2 = (-b-d)/2/a\n return (s1,s2)\n```\n\n\n```python\necsec(2,-6,4)\n```\n\n\n\n\n (2.0, 1.0)\n\n\n\nLos paréntesis de la tupla son opcionales.\n\n\n```python\na,b = ecsec(1,-3,2)\n\nb\n```\n\n\n\n\n 1.0\n\n\n\nLas variables globales son visibles dentro de las funciones y las asignaciones crean variables locales (a menos que el nombre se declare `global`).\n\n\n```python\na = 5\n\nb = 8\n\ndef f(x):\n b = a+1\n return b\n\nprint(f(3))\nprint(b)\n```\n\n 6\n 8\n\n\n\n```python\na = 5\n\nb = 8\n\ndef f(x):\n global b\n b = a+1\n return b\n\nprint(f(3))\nprint(b)\n```\n\n 6\n 6\n\n\nArgumentos por omisión:\n\n\n```python\ndef incre(x,y=1):\n return x + y\n\nprint(incre(5))\nprint(incre(5,3))\n```\n\n 6\n 8\n\n\nArgumentos por nombre:\n\n\n```python\nincre(y=3, x=2)\n```\n\n\n\n\n 5\n\n\n\nDocumentación:\n\n\n```python\n# ? sum\nhelp(sum)\n```\n\n Help on built-in function sum in module builtins:\n \n sum(iterable, start=0, /)\n Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n \n When the iterable is empty, return the start value.\n This function is intended specifically for use with numeric values and may\n reject non-numeric types.\n \n\n\n\n```python\ndef fun(n):\n \"\"\"Una función muy simple que calcula el triple de su argumento.\"\"\"\n return 3*n\n```\n\n\n```python\nhelp(fun)\n```\n\n Help on function fun in module __main__:\n \n fun(n)\n Una función muy simple que calcula el triple de su argumento.\n \n\n\n### bibliotecas\n\nLas funciones definidas en un archivo se pueden utilizar directamente haciendo un `import`. Existe una convención para definir una función `main` que se ejecuta cuando el archivo se arranca como programa y suele usarse para ejecutar tests.\n\n### programación funcional\n\nEn Python 3 las construcciones funcionales crean secuencias \"bajo demanda\".\n\n\n```python\nmap(sp,range(5))\n```\n\n\n\n\n \n\n\n\n\n```python\nfor k in map(sp,range(5)):\n print(k)\n```\n\n 41\n 43\n 47\n 53\n 61\n\n\n\n```python\nlist(map(sp,range(5)))\n```\n\n\n\n\n [41, 43, 47, 53, 61]\n\n\n\n\n```python\nlist(filter(lambda x: x%2 == 1, range(10)))\n```\n\n\n\n\n [1, 3, 5, 7, 9]\n\n\n\nEs poco frecuente usar explícitamente map y filter, ya que su efecto se consigue de forma más cómoda con list comprehensions:\n\n\n```python\n[k**2 for k in range(10) if k >5 ]\n```\n\n\n\n\n [36, 49, 64, 81]\n\n\n\n\n```python\ndef divis(n):\n return [k for k in range(2,n) if n%k==0]\n```\n\n\n```python\ndivis(12)\n```\n\n\n\n\n [2, 3, 4, 6]\n\n\n\n\n```python\ndivis(1001)\n```\n\n\n\n\n [7, 11, 13, 77, 91, 143]\n\n\n\n\n```python\ndef perfect(n):\n return sum(divis(n)) + 1 == n\n```\n\n\n```python\nperfect(4)\n```\n\n\n\n\n False\n\n\n\n\n```python\nperfect(6)\n```\n\n\n\n\n True\n\n\n\n\n```python\ndef prime(n):\n return divis(n)==[]\n```\n\n\n```python\n[k for k in range(2,21) if prime(k)]\n```\n\n\n\n\n [2, 3, 5, 7, 11, 13, 17, 19]\n\n\n\n\n```python\nfrom functools import reduce\nimport operator\n\ndef product(l):\n return reduce(operator.mul,l,1)\n```\n\n\n```python\nproduct(range(1,10+1))\n```\n\n\n\n\n 3628800\n\n\n\nFunción que construye funciones:\n\n\n```python\ndef mkfun(y):\n return lambda x: x+y\n```\n\n\n```python\nf = mkfun(1)\ng = mkfun(5)\n\nprint(f(10))\nprint(g(10))\n```\n\n 11\n 15\n\n\n\n```python\nfs = list(map(mkfun,range(1,6)))\n\nprint(fs[0](10))\nprint(fs[4](10))\n```\n\n 11\n 15\n\n\n## arrays\n\nGran parte del éxito de Python se debe a [numpy](http://www.numpy.org/).\n\n\n```python\nimport numpy as np\n```\n\nConstrucción a partir de listas (u otros contenedores):\n\n\n```python\nm = np.array([[5,3, 2,10],\n [2,0, 7, 0],\n [1,1,-3, 6]])\n```\n\n\n```python\nm[1,2]\n```\n\n\n\n\n 7\n\n\n\nInspección de su tipo y estructura:\n\n\n```python\ntype(m)\n```\n\n\n\n\n numpy.ndarray\n\n\n\n\n```python\nm.dtype\n```\n\n\n\n\n dtype('int64')\n\n\n\n\n```python\nm.shape\n```\n\n\n\n\n (3, 4)\n\n\n\n\n```python\nm.ndim\n```\n\n\n\n\n 2\n\n\n\n\n```python\nlen(m)\n```\n\n\n\n\n 3\n\n\n\n\n```python\nm.size\n```\n\n\n\n\n 12\n\n\n\nLas operaciones elemento a elemento son automáticas:\n\n\n```python\n5*m + 2\n```\n\n\n\n\n array([[ 27, 17, 12, 52],\n [ 12, 2, 37, 2],\n [ 7, 7, -13, 32]])\n\n\n\nConstructores especiales:\n\n\n```python\nnp.zeros([2,3])\n```\n\n\n\n\n array([[0., 0., 0.],\n [0., 0., 0.]])\n\n\n\n\n```python\nnp.ones([4])\n```\n\n\n\n\n array([1., 1., 1., 1.])\n\n\n\n\n```python\nnp.linspace(0,5,11)\n```\n\n\n\n\n array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. ])\n\n\n\n\n```python\nnp.arange(10)\n```\n\n\n\n\n array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n\n\n\n```python\nnp.arange(1,10,0.5)\n```\n\n\n\n\n array([1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. ,\n 7.5, 8. , 8.5, 9. , 9.5])\n\n\n\n\n```python\nnp.eye(7)\n```\n\n\n\n\n array([[1., 0., 0., 0., 0., 0., 0.],\n [0., 1., 0., 0., 0., 0., 0.],\n [0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0.],\n [0., 0., 0., 0., 1., 0., 0.],\n [0., 0., 0., 0., 0., 1., 0.],\n [0., 0., 0., 0., 0., 0., 1.]])\n\n\n\nIteración, a lo largo de la primera dimensión:\n\n\n```python\nfor e in np.arange(4):\n print(e)\n```\n\n 0\n 1\n 2\n 3\n\n\n\n```python\nfor e in m:\n print(e)\n```\n\n [ 5 3 2 10]\n [2 0 7 0]\n [ 1 1 -3 6]\n\n\n\n```python\nsum(m)\n```\n\n\n\n\n array([ 8, 4, 6, 16])\n\n\n\n\n```python\nnp.sum(m,axis=1)\n```\n\n\n\n\n array([20, 9, 5])\n\n\n\nOperaciones matriciales:\n\n\n```python\nm.T\n```\n\n\n\n\n array([[ 5, 2, 1],\n [ 3, 0, 1],\n [ 2, 7, -3],\n [10, 0, 6]])\n\n\n\n\n```python\nv = np.array([3,2,-5,8])\n```\n\nEl producto de matrices, el producto escalar de vectores, y su generalización para arrays multidimensionales se expresa con el símbolo `@` (que representa a la función `dot`).\n\n\n```python\nm @ v\n```\n\n\n\n\n array([ 91, -29, 68])\n\n\n\n\n```python\nnp.diag([10,0,1]) @ m\n```\n\n\n\n\n array([[ 50, 30, 20, 100],\n [ 0, 0, 0, 0],\n [ 1, 1, -3, 6]])\n\n\n\nLas funciones matemáticas están optimizadas para operar con arrays elemento a elemento:\n\n\n```python\nx = np.linspace(0,2*np.pi,30)\n\nx\n```\n\n\n\n\n array([0. , 0.21666156, 0.43332312, 0.64998469, 0.86664625,\n 1.08330781, 1.29996937, 1.51663094, 1.7332925 , 1.94995406,\n 2.16661562, 2.38327719, 2.59993875, 2.81660031, 3.03326187,\n 3.24992343, 3.466585 , 3.68324656, 3.89990812, 4.11656968,\n 4.33323125, 4.54989281, 4.76655437, 4.98321593, 5.1998775 ,\n 5.41653906, 5.63320062, 5.84986218, 6.06652374, 6.28318531])\n\n\n\n\n```python\ny = np.sin(x) + np.cos(2*x)\ny\n```\n\n\n\n\n array([ 1. , 1.12254586, 1.06727539, 0.87270255, 0.60038006,\n 0.32232498, 0.10669282, 0.00439546, 0.03917335, 0.20298123,\n 0.45755084, 0.74183837, 0.9839623 , 1.1153946 , 1.08473957,\n 0.86850154, 0.47679154, -0.04714542, -0.63356055, -1.19782715,\n -1.65497221, -1.93447969, -1.99267137, -1.82040717, -1.44469911,\n -0.92394405, -0.33764588, 0.22749718, 0.69260498, 1. ])\n\n\n\nReconfiguración de los elementos:\n\n\n```python\nnp.arange(12)\n```\n\n\n\n\n array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])\n\n\n\n\n```python\nnp.arange(12).reshape(3,2,2)\n```\n\n\n\n\n array([[[ 0, 1],\n [ 2, 3]],\n \n [[ 4, 5],\n [ 6, 7]],\n \n [[ 8, 9],\n [10, 11]]])\n\n\n\n### matrices por bloques\n\n\n```python\nnp.append(m,[[100,200,300,400],\n [0, 10, 0, 1] ],axis=0)\n```\n\n\n\n\n array([[ 5, 3, 2, 10],\n [ 2, 0, 7, 0],\n [ 1, 1, -3, 6],\n [100, 200, 300, 400],\n [ 0, 10, 0, 1]])\n\n\n\n\n```python\nnp.hstack([np.zeros([3,3]),np.ones([3,2])])\n```\n\n\n\n\n array([[0., 0., 0., 1., 1.],\n [0., 0., 0., 1., 1.],\n [0., 0., 0., 1., 1.]])\n\n\n\n\n```python\nnp.vstack([np.eye(3),5*np.ones([2,3])])\n```\n\n\n\n\n array([[1., 0., 0.],\n [0., 1., 0.],\n [0., 0., 1.],\n [5., 5., 5.],\n [5., 5., 5.]])\n\n\n\nnumpy proporciona un tipo especial `matrix` para los arrays de 2 dimensiones pero [se recomienda no usarlo](https://stackoverflow.com/questions/4151128/what-are-the-differences-between-numpy-arrays-and-matrices-which-one-should-i-u) o usarlo con cuidado.\n\n### automatic broadcasting\n\nLas operaciones elemento a elemento argumentos con las mismas dimensiones. Pero si alguna dimensión es igual a uno, se sobreentiende que los elementos se replican en esa dimensión para coincidir con el otro array.\n\n\n```python\nm = np.array([[1, 2, 3, 4]\n ,[5, 6, 7, 8]\n ,[9,10,11,12]])\n```\n\n\n```python\nm + [[10],\n [20],\n [30]]\n```\n\n\n\n\n array([[11, 12, 13, 14],\n [25, 26, 27, 28],\n [39, 40, 41, 42]])\n\n\n\n\n```python\nm + [100,200,300,400]\n```\n\n\n\n\n array([[101, 202, 303, 404],\n [105, 206, 307, 408],\n [109, 210, 311, 412]])\n\n\n\n\n```python\nnp.array([[1,2,3,4]]) + np.array([[100],\n [200],\n [300]])\n```\n\n\n\n\n array([[101, 102, 103, 104],\n [201, 202, 203, 204],\n [301, 302, 303, 304]])\n\n\n\n### slices\n\nExtracción de elementos y \"submatrices\" o \"subarrays\", seleccionando intervalos de filas, columnas, etc.:\n\n\n```python\nm = np.arange(42).reshape(6,7)\nm\n```\n\n\n\n\n array([[ 0, 1, 2, 3, 4, 5, 6],\n [ 7, 8, 9, 10, 11, 12, 13],\n [14, 15, 16, 17, 18, 19, 20],\n [21, 22, 23, 24, 25, 26, 27],\n [28, 29, 30, 31, 32, 33, 34],\n [35, 36, 37, 38, 39, 40, 41]])\n\n\n\n\n```python\nm[1,2]\n```\n\n\n\n\n 9\n\n\n\n\n```python\nm[2:5,1:4]\n```\n\n\n\n\n array([[15, 16, 17],\n [22, 23, 24],\n [29, 30, 31]])\n\n\n\n\n```python\nm[:3, 4:]\n```\n\n\n\n\n array([[ 4, 5, 6],\n [11, 12, 13],\n [18, 19, 20]])\n\n\n\n\n```python\nm[[1,0,0,2,1],:]\n```\n\n\n\n\n array([[ 7, 8, 9, 10, 11, 12, 13],\n [ 0, 1, 2, 3, 4, 5, 6],\n [ 0, 1, 2, 3, 4, 5, 6],\n [14, 15, 16, 17, 18, 19, 20],\n [ 7, 8, 9, 10, 11, 12, 13]])\n\n\n\nLos índices negativos indican que se empieza a contar desde el final.\n\n\n```python\n# las dos últimas columnas y todas las filas menos las tres últimas.\nm[:-3,-2:]\n```\n\n\n\n\n array([[ 5, 6],\n [12, 13],\n [19, 20]])\n\n\n\n\n```python\n# la penúltima columna\nm[:,-2]\n```\n\n\n\n\n array([ 5, 12, 19, 26, 33, 40])\n\n\n\n\n```python\n# la penúltima columna pero como array 2D (matriz), para que se vea como un vector columna\nm[:,[-2]]\n```\n\n\n\n\n array([[ 5],\n [12],\n [19],\n [26],\n [33],\n [40]])\n\n\n\n### masks\n\nExtracción de elementos que cumplen una condición:\n\n\n```python\nn = np.arange(10)\n\nn\n```\n\n\n\n\n array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n\n\n\n\n```python\nn < 5\n```\n\n\n\n\n array([ True, True, True, True, True, False, False, False, False,\n False])\n\n\n\n\n```python\nn[n<5]\n```\n\n\n\n\n array([0, 1, 2, 3, 4])\n\n\n\n\n```python\nk = np.arange(1,101)\n\n(k ** 2)[(k>10) & (k**3 < 2000)]\n```\n\n\n\n\n array([121, 144])\n\n\n\n### I/O\n\nLa función `np.loadtxt` permite cargar los datos de los arrays a partir de ficheros de texto. También es posible guardar y recuperar arrays en formato binario.\n\n## gráficas\n\nUno de los paquetes gráficos más conocidos es `matplotlib`, que puede utilizarse con un interfaz muy parecido al de Matlab/Octave.\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n# para insertar los gráficos en el notebook\n%matplotlib inline\n\n# para generar ventanas independientes\n# %matplotlib qt\n# %matplotib tk\n```\n\n\n```python\nx=np.linspace(0,2*np.pi,200)\n```\n\n\n```python\nplt.plot(np.sin(x))\n```\n\n\n```python\nplt.plot(np.cos(x),np.sin(x)); plt.axis('equal');\n```\n\n\n```python\nplt.plot(x,np.sin(x), x,np.cos(x));\n```\n\n\n```python\nplt.plot(x,np.sin(x),color='red')\nplt.plot(x,np.sin(2*x),color='black')\nplt.plot([1,2.5],[-0.5,0],'.',markerSize=15);\nplt.legend(['hola','fun','puntos']);\nplt.xlabel('x'); plt.ylabel('y'); plt.title('bonito plot'); plt.axis('tight');\n```\n\nEl gráfico se puede exportar en el formato deseado:\n\n\n```python\n# plt.savefig('result.pdf') # o .svg, .png, .jpg, etc.\n```\n\n\n```python\nplt.plot(x,np.exp(x)); plt.axis([0,3,-1,5]);\n```\n\n\n```python\nfor k in [1,2,3]:\n plt.plot(x,np.sin(k*x))\nplt.grid()\n```\n\n\n```python\ndef espiral(n):\n t = np.linspace(0,n*2*np.pi,1000)\n r = 3 * t\n x = r * np.cos(t)\n y = r * np.sin(t)\n plt.plot(x,y)\n plt.axis('equal')\n plt.axis('off')\n\nespiral(4)\n```\n\n\n```python\nimport numpy.random as rnd\n\ndef randwalk(n,s):\n p = s*rnd.randn(n,2)\n r = np.cumsum(p,axis=0)\n x = r[:,0]\n y = r[:,1]\n plt.plot(x,y)\n plt.axis('equal');\n```\n\n\n```python\nplt.figure(figsize=(4,4))\nrandwalk(1000,1)\n```\n\n\n```python\nplt.figure(figsize=(8,8))\nx = np.linspace(0,6*np.pi,100);\n\nplt.subplot(2,2,1)\nplt.plot(x,np.sin(x),'r')\n\nplt.subplot(2,2,2)\nplt.plot(x,np.cos(x))\n\nplt.subplot(2,2,3)\nplt.plot(x,np.sin(2*x))\n\nplt.subplot(2,2,4)\nplt.plot(x,np.cos(2*x),'g');\n```\n\n\n```python\nx,y = np.mgrid[-3:3:0.2,-3:3:0.2]\n\nz = x**2-y**2-1\n```\n\n\n```python\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom matplotlib import cm\n\nfig = plt.figure(figsize=(8,6))\nax = fig.add_subplot(111, projection='3d')\n\nax.plot_surface(x,y,x**2-y**2, cmap=cm.coolwarm, linewidth=0.5, rstride=2, cstride=2);\n```\n\n\n```python\nplt.figure(figsize=(6,6))\nplt.contour(x,y, z , colors=['k']);\nplt.axis('equal');\n```\n\n### animaciones\n\n\n```python\n# si se produce un error:\n# conda install -c menpo ffmpeg\n\nfrom matplotlib import animation, rc\nfrom IPython.display import HTML\nrc('animation', html='html5')\n```\n\n\n```python\nx = np.linspace(0,2,100)\n\ndef wave(lam,freq,x,t):\n return 1*np.sin(2*np.pi*(x/lam - t*freq))\n```\n\n\n```python\nfig, ax = plt.subplots()\nplt.grid()\nplt.title('onda viajera')\nplt.xlabel('x');\nplt.close();\nax.set_xlim(( 0, 2))\nax.set_ylim((-1.1, 1.1))\n\nline1, = ax.plot([], [], '-')\n#line2, = ax.plot([], [], '.', markerSize=20)\n\nlam = 0.8\nfreq = 1/4\n\ndef animate(i):\n t = i/25\n line1.set_data(x,wave(lam,freq,x,t))\n #line2.set_data(1,f(lam,freq,1,t))\n return ()\n\nanimation.FuncAnimation(fig, animate, frames=100, interval=1000/25, blit=True)\n```\n\n\n\n\n\n\n\n\n### data frames\n\nEl módulo `pandas` proporciona el tipo \"dataframe\", muy utilizado en análisis de datos. Permite leer conjuntos de datos almacenados en archivos que pueden estar incluso en una máquina remota.\n\n\n```python\nimport pandas as pd\n\ndf = pd.read_table('https://robot.inf.um.es/material/data/ConstanteHubbleDatos-1.txt', sep='\\s+', comment='#')\ndf\n```\n\n\n\n\n\n\n
\n \n \n V(km/s) \n Redshift \n Magnitud \n \n \n \n \n 0 \n 18287 \n 0.060998 \n 17.62 \n \n \n 1 \n 5691 \n 0.018983 \n 15.00 \n \n \n 2 \n 26382 \n 0.088000 \n 18.59 \n \n \n 3 \n 5996 \n 0.020000 \n 15.54 \n \n \n 4 \n 19202 \n 0.064051 \n 15.30 \n \n \n 5 \n 23684 \n 0.079000 \n 16.56 \n \n \n 6 \n 11702 \n 0.039034 \n 17.14 \n \n \n 7 \n 17284 \n 0.057653 \n 13.50 \n \n \n 8 \n 13491 \n 0.045000 \n 17.80 \n \n \n 9 \n 10566 \n 0.035244 \n 15.25 \n \n \n 10 \n 14718 \n 0.049094 \n 15.60 \n \n \n 11 \n 13491 \n 0.045000 \n 14.52 \n \n \n 12 \n 16325 \n 0.054453 \n 15.30 \n \n \n 13 \n 20686 \n 0.069000 \n 16.80 \n \n \n 14 \n 1808 \n 0.006031 \n 11.16 \n \n \n 15 \n 7603 \n 0.025361 \n 15.18 \n \n \n 16 \n 1018 \n 0.003395 \n 12.24 \n \n \n 17 \n 321 \n 0.001071 \n 13.00 \n \n \n 18 \n 3106 \n 0.010360 \n 12.49 \n \n \n 19 \n 9426 \n 0.031442 \n 14.53 \n \n \n 20 \n 7464 \n 0.024897 \n 15.21 \n \n \n 21 \n 15143 \n 0.050512 \n 17.40 \n \n \n 22 \n 407 \n 0.001358 \n 10.87 \n \n \n 23 \n 7257 \n 0.024207 \n 14.60 \n \n \n 24 \n 9193 \n 0.030664 \n 15.10 \n \n \n 25 \n 12137 \n 0.040485 \n 14.75 \n \n \n 26 \n 4264 \n 0.014224 \n 14.98 \n \n \n 27 \n 4381 \n 0.014615 \n 14.15 \n \n \n 28 \n 22484 \n 0.075000 \n 17.43 \n \n \n 29 \n 15162 \n 0.050575 \n 16.50 \n \n \n 30 \n 30000 \n 0.101000 \n 18.90 \n \n \n 31 \n 12981 \n 0.043300 \n 15.23 \n \n \n 32 \n 8803 \n 0.029364 \n 14.90 \n \n \n
\n
\n\n$$\n\\begin{equation}\n\\boldsymbol{F}_{ij}=-\\boldsymbol{F}_{ji}. \n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nFor the abovementioned two objects we have thus $\\boldsymbol{F}_{12}=-\\boldsymbol{F}_{21}$.\n\n## Newton's Second Law and Momentum\n\nWith the net forces acting on each object we can now related the momentum to the forces via\n\n$$\n\\boldsymbol{F}_1^{\\mathrm{net}}=m_1\\boldsymbol{a}_i=m_1\\frac{d\\boldsymbol{v}_1}{dt}=\\boldsymbol{F}_1^{\\mathrm{ext}}+\\boldsymbol{F}_{12},\n$$\n\nand\n\n$$\n\\boldsymbol{F}_2^{\\mathrm{net}}=m_2\\boldsymbol{a}_2=m_2\\frac{d\\boldsymbol{v}_2}{dt}=\\boldsymbol{F}_2^{\\mathrm{ext}}+\\boldsymbol{F}_{21}.\n$$\n\nRecalling our definition for the linear momentum we have then\n\n$$\n\\frac{d\\boldsymbol{p}_1}{dt}=\\boldsymbol{F}_1^{\\mathrm{ext}}+\\boldsymbol{F}_{12},\n$$\n\nand\n\n$$\n\\frac{d\\boldsymbol{p}_2}{dt}=\\boldsymbol{F}_2^{\\mathrm{ext}}+\\boldsymbol{F}_{21}.\n$$\n\n## The total Momentum\n\nThe total momentum $\\boldsymbol{P}$ is defined as the sum of the individual momenta, meaning that we can rewrite\n\n$$\n\\boldsymbol{F}_1^{\\mathrm{net}}+\\boldsymbol{F}_2^{\\mathrm{net}}=\\frac{d\\boldsymbol{p}_1}{dt}+\\frac{d\\boldsymbol{p}_2}{dt}=\\frac{d\\boldsymbol{P}}{dt},\n$$\n\nthat is the derivate with respect to time of the total momentum. If we now\nwrite the net forces as sums of the external plus internal forces\nbetween the objects we have\n\n$$\n\\frac{d\\boldsymbol{P}}{dt}=\\boldsymbol{F}_1^{\\mathrm{ext}}+\\boldsymbol{F}_{12}+\\boldsymbol{F}_2^{\\mathrm{ext}}+\\boldsymbol{F}_{21}=\\boldsymbol{F}_1^{\\mathrm{ext}}+\\boldsymbol{F}_2^{\\mathrm{ext}}.\n$$\n\nThe derivative of the total momentum is just **the sum of the external\nforces**. If we assume that the external forces are zero and that only\ninternal (here two-body forces) are at play, we obtain the important\nresult that the derivative of the total momentum is zero. This means\nagain that the total momentum is a constant of the motion and\nconserved quantity. This is a very important result that we will use\nin many applications to come.\n\n## Newton's Second Law\n\nLet us now general to several objects $N$ and let us also assume that there are no external forces. We will label such a system as **an isolated system**. \n\nNewton's second law, $\\boldsymbol{F}=m\\boldsymbol{a}$, can be written for a particle $i$ as\n\n\n
\n\n$$\n\\begin{equation}\n\\boldsymbol{F}_i=\\sum_{j\\ne i}^N \\boldsymbol{F}_{ij}=m_i\\boldsymbol{a}_i,\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nwhere $\\boldsymbol{F}_i$ (a single subscript) denotes the net force acting on $i$ from the other objects/particles.\nBecause the mass of $i$ is fixed and we assume it does not change with time, one can see that\n\n\n
\n\n$$\n\\begin{equation}\n\\boldsymbol{F}_i=\\frac{d}{dt}m_i\\boldsymbol{v}_i=\\sum_{j\\ne i}^N\\boldsymbol{F}_{ij}.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\n## Summing over all Objects/Particles\n\nNow, one can sum over all the objects/particles and obtain\n\n$$\n\\frac{d}{dt}\\sum_i m_iv_i=\\sum_{ij, i\\ne j}^N\\boldsymbol{F}_{ij}=0.\n$$\n\nHow did we arrive at the last step? We rewrote the double sum as\n\n$$\n\\sum_{ij, i\\ne j}^N\\boldsymbol{F}_{ij}=\\sum_i^N\\sum_{j>i}\\left(\\boldsymbol{F}_{ij}+\\boldsymbol{F}_{ji}\\right),\n$$\n\nand using Newton's third law which states that\n$\\boldsymbol{F}_{ij}=-\\boldsymbol{F}_{ji}$, we obtain that the net sum over all the two-particle\nforces is zero when we only consider so-called **internal forces**.\nStated differently, the last step made use of the fact that for every\nterm $ij$, there is an equivalent term $ji$ with opposite\nforce. Because the momentum is defined as $m\\boldsymbol{v}$, for a system of\nparticles, we have thus\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d}{dt}\\sum_im_i\\boldsymbol{v}_i=0,~~{\\rm for~isolated~particles}.\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\n## Conservation of total Momentum\n\nBy \"isolated\" one means that the only force acting on any particle $i$\nare those originating from other particles in the sum, i.e. \"no\nexternal\" forces. Thus, Newton's third law leads to the conservation\nof total momentum,\n\n$$\n\\boldsymbol{P}=\\sum_i m_i\\boldsymbol{v}_i,\n$$\n\nand we have\n\n$$\n\\frac{d}{dt}\\boldsymbol{P}=0.\n$$\n\n## Example: Rocket Science\n\nConsider a rocket of mass $M$ moving with velocity $v$. After a\nbrief instant, the velocity of the rocket is $v+\\Delta v$ and the mass\nis $M-\\Delta M$. Momentum conservation gives\n\n$$\n\\begin{eqnarray*}\nMv&=&(M-\\Delta M)(v+\\Delta v)+\\Delta M(v-v_e)\\\\\n0&=&-\\Delta Mv+M\\Delta v+\\Delta M(v-v_e),\\\\\n0&=&M\\Delta v-\\Delta Mv_e.\n\\end{eqnarray*}\n$$\n\nIn the second step we ignored the term $\\Delta M\\Delta v$ because it is doubly small. The last equation gives\n\n$$\n\\begin{eqnarray}\n\\Delta v&=&\\frac{v_e}{M}\\Delta M,\\\\\n\\nonumber\n\\frac{dv}{dt}&=&\\frac{v_e}{M}\\frac{dM}{dt}.\n\\end{eqnarray}\n$$\n\n## Integrating the Equations\n\nIntegrating the expression with lower limits $v_0=0$ and $M_0$, one finds\n\n$$\n\\begin{eqnarray*}\nv&=&v_e\\int_{M_0}^M \\frac{dM'}{M'}\\\\\nv&=&v_e\\ln(M/M_0)\\\\\n&=&v_e\\ln[(M_0-\\alpha t)/M_0].\n\\end{eqnarray*}\n$$\n\nBecause the total momentum of an isolated system is constant, one can\nalso quickly see that the center of mass of an isolated system is also\nconstant. The center of mass is the average position of a set of\nmasses weighted by the mass,\n\n\n
\n\n$$\n\\begin{equation}\n\\bar{x}=\\frac{\\sum_im_ix_i}{\\sum_i m_i}.\n\\label{_auto5} \\tag{5}\n\\end{equation}\n$$\n\n## Rate of Change\n\nThe rate of change of $\\bar{x}$ is\n\n$$\n\\dot{\\bar{x}}=\\frac{1}{M}\\sum_i m_i\\dot{x}_i=\\frac{1}{M}P_x.\n$$\n\nThus if the total momentum is constant the center of mass moves at a\nconstant velocity, and if the total momentum is zero the center of\nmass is fixed.\n\n## Conservation of Angular Momentum\n\nThe angular momentum is defined as\n\n\n
\n\n$$\n\\begin{equation}\n\\boldsymbol{L}=\\boldsymbol{r}\\times\\boldsymbol{p}=m\\boldsymbol{r}\\times\\boldsymbol{v}.\n\\label{_auto6} \\tag{6}\n\\end{equation}\n$$\n\nIt means that the angular momentum is perpendicular to the plane defined by position $\\boldsymbol{r}$ and the momentum $\\boldsymbol{p}$ via $\\boldsymbol{r}\\times \\boldsymbol{p}$.\n\n## Rate of Change of Angular Momentum\n\nThe rate of change of the angular momentum is\n\n$$\n\\frac{d\\boldsymbol{L}}{dt}=m\\boldsymbol{v}\\times\\boldsymbol{v}+m\\boldsymbol{r}\\times\\dot{\\boldsymbol{v}}=\\boldsymbol{r}\\times{\\boldsymbol{F}}\n$$\n\nThe first term is zero because $\\boldsymbol{v}$ is parallel to itself, and the\nsecond term defines the so-called torque. If $\\boldsymbol{F}$ is parallel to $\\boldsymbol{r}$ then the torque is zero and we say that angular momentum is conserved.\n\nIf the force is not radial, $\\boldsymbol{r}\\times\\boldsymbol{F}\\ne 0$ as above, and angular momentum is no longer conserved,\n\n\n
\n\n$$\n\\begin{equation}\n\\frac{d\\boldsymbol{L}}{dt}=\\boldsymbol{r}\\times\\boldsymbol{F}\\equiv\\boldsymbol{\\tau},\n\\label{_auto7} \\tag{7}\n\\end{equation}\n$$\n\nwhere $\\boldsymbol{\\tau}$ is the torque.\n\n## The Torque, Example 1 (hw 4, exercise 4)\n\nLet us assume we have an initial position $\\boldsymbol{r}_0=x_0\\boldsymbol{e}_1+y_0\\boldsymbol{e}_2$ at a time $t_0=0$.\nWe add now a force in the positive $x$-direction\n\n$$\n\\boldsymbol{F}=F_x\\boldsymbol{e}_1=\\frac{d\\boldsymbol{p}}{dt},\n$$\n\nwhere we used the force as defined by the time derivative of the momentum.\n\nWe can use this force (and its pertinent acceleration) to find the velocity via the relation\n\n$$\n\\boldsymbol{v}(t)=\\boldsymbol{v}_0+\\int_{t_0}^t\\boldsymbol{a}dt',\n$$\n\nand with $\\boldsymbol{v}_0=0$ we have\n\n$$\n\\boldsymbol{v}(t)=\\int_{t_0}^t\\frac{\\boldsymbol{F}}{m}dt',\n$$\n\nwhere $m$ is the mass of the object.\n\n## The Torque, Example 1 (hw 4, exercise 4)\n\nSince the force acts only in the $x$-direction, we have after integration\n\n$$\n\\boldsymbol{v}(t)=\\frac{\\boldsymbol{F}}{m}t=\\frac{F_x}{m}t\\boldsymbol{e}_1=v_x(t)\\boldsymbol{e}_1.\n$$\n\nThe momentum is in turn given by $\\boldsymbol{p}=p_x\\boldsymbol{e}_1=mv_x\\boldsymbol{e}_1=F_xt\\boldsymbol{e}_1$.\n\nIntegrating over time again we find the final position as (note the force depends only on the $x$-direction)\n\n$$\n\\boldsymbol{r}(t)=(x_0+\\frac{1}{2}\\frac{F_x}{m}t^2) \\boldsymbol{e}_1+y_0\\boldsymbol{e}_2.\n$$\n\nThere is no change in the position in the $y$-direction since the force acts only in the $x$-direction.\n\n## The Torque, Example 1 (hw 4, exercise 4)\n\nWe can now compute the angular momentum given by\n\n$$\n\\boldsymbol{l}=\\boldsymbol{r}\\times\\boldsymbol{p}=\\left[(x_0+\\frac{1}{2}\\frac{F_x}{m}t^2) \\boldsymbol{e}_1+y_0\\boldsymbol{e}_2\\right]\\times F_xt\\boldsymbol{e}_1.\n$$\n\nComputing the cross product we find\n\n$$\n\\boldsymbol{l}=-y_0F_xt\\boldsymbol{e}_3=-y_0F_xt\\boldsymbol{e}_z.\n$$\n\nThe torque is the time derivative of the angular momentum and we have\n\n$$\n\\boldsymbol{\\tau}=-y_0F_x\\boldsymbol{e}_3=-y_0F_x\\boldsymbol{e}_z.\n$$\n\nThe torque is non-zero and angular momentum is not conserved.\n\n## The Torque, Example 2\n\nOne can write the torque about a given axis, which we will denote as $\\hat{z}$, in polar coordinates, where\n\n$$\n\\begin{eqnarray}\nx&=&r\\sin\\theta\\cos\\phi,~~y=r\\sin\\theta\\cos\\phi,~~z=r\\cos\\theta,\n\\end{eqnarray}\n$$\n\nto find the $z$ component of the torque,\n\n$$\n\\begin{eqnarray}\n\\tau_z&=&xF_y-yF_x\\\\\n\\nonumber\n&=&-r\\sin\\theta\\left\\{\\cos\\phi \\partial_y-\\sin\\phi \\partial_x\\right\\}V(x,y,z).\n\\end{eqnarray}\n$$\n\n## Chain Rule and Partial Derivatives\n\nOne can use the chain rule to write the partial derivative w.r.t. $\\phi$ (keeping $r$ and $\\theta$ fixed),\n\n$$\n\\begin{eqnarray}\n\\partial_\\phi&=&\\frac{\\partial x}{\\partial\\phi}\\partial_x+\\frac{\\partial_y}{\\partial\\phi}\\partial_y\n+\\frac{\\partial z}{\\partial\\phi}\\partial_z\\\\\n\\nonumber\n&=&-r\\sin\\theta\\sin\\phi\\partial_x+\\sin\\theta\\cos\\phi\\partial_y.\n\\end{eqnarray}\n$$\n\nCombining the two equations,\n\n$$\n\\begin{eqnarray}\n\\tau_z&=&-\\partial_\\phi V(r,\\theta,\\phi).\n\\end{eqnarray}\n$$\n\nThus, if the potential is independent of the azimuthal angle $\\phi$,\nthere is no torque about the $z$ axis and $L_z$ is conserved.\n\n## System of Isolated Particles\n\nFor a system of isolated particles, one can write\n\n$$\n\\begin{eqnarray}\n\\frac{d}{dt}\\sum_i\\boldsymbol{L}_i&=&\\sum_{i\\ne j}\\boldsymbol{r}_i\\times \\boldsymbol{F}_{ij}\\\\\n\\nonumber\n&=&\\frac{1}{2}\\sum_{ij, i\\ne j} \\boldsymbol{r}_i\\times \\boldsymbol{F}_{ij}+\\boldsymbol{r}_j\\times\\boldsymbol{F}_{ji}\\\\\n\\nonumber\n&=&\\frac{1}{2}\\sum_{ij, i\\ne j} (\\boldsymbol{r}_i-\\boldsymbol{r}_j)\\times\\boldsymbol{F}_{ij}=0,\n\\end{eqnarray}\n$$\n\nwhere the last step used Newton's third law,\n$\\boldsymbol{F}_{ij}=-\\boldsymbol{F}_{ji}$. If the forces between the particles are\nradial, i.e. $\\boldsymbol{F}_{ij} ~||~ (\\boldsymbol{r}_i-\\boldsymbol{r}_j)$, then each term in\nthe sum is zero and the net angular momentum is fixed. Otherwise, you\ncould imagine an isolated system that would start spinning\nspontaneously.\n\n## Homework 3, exercises 5 and 6, numerical solution\n\n\n```python\n%matplotlib inline\n\n# let's start by importing useful packages we are familiar with\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\nWe will choose the following values\n1. mass $m=0,2$ kg\n\n2. accelleration (gravity) $g=9.81$ m/s$^{2}$.\n\n3. initial position is the height $h=2$ m\n\n4. initial velocities $v_{x,0}=v_{y,0}=10$ m/s\n\nYou need also to define an initial time and \nthe step size $\\Delta t$. We can define the step size $\\Delta t$ as the difference between any\ntwo neighboring values in time (time steps) that we analyze within\nsome range. It can be determined by dividing the interval we are\nanalyzing, which in our case is time $t_{\\mathrm{final}}-t_0$, by the number of steps we\nare taking $(N)$. This gives us a step size $\\Delta t = \\dfrac{t_{\\mathrm{final}}-t_0}{N}$.\n\nWith these preliminaries we are now ready to plot our results from exercise 5.\n\nIn setting up our code we need to\n\n1. Define and obtain all initial values, constants, and time to be analyzed with step sizes as done above (you can use the same values)\n\n2. Calculate the velocity using $v_{i+1} = v_{i} + (\\Delta t)*a_{i}$\n\n3. Calculate the position using $pos_{i+1} = r_{i} + (\\Delta t)*v_{i}$\n\n4. Calculate the new acceleration $a_{i+1}$.\n\n5. Repeat steps 2-4 for all time steps within a loop.\n\n\n```python\n# Exercise 6, hw3, brute force way with declaration of vx, vy, x and y\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n# Output file\noutfile = open(data_path(\"Eulerresults.dat\"),'w')\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\n\ng = 9.80655 #m/s^2\n# The mass and the drag constant D\nD = 0.00245 #mass/length kg/m\nm = 0.2 #kg, mass of falling object\nDeltaT = 0.001\n#set up arrays \ntfinal = 1.4\n# set up number of points for all variables\nn = ceil(tfinal/DeltaT)\n# define scaling constant vT used in analytical solution\nvT = sqrt(m*g/D)\n# set up arrays for t, a, v, and y and arrays for analytical results\n#brute force setting up of arrays for x and y, vx, vy, ax and ay\nt = np.zeros(n)\nvy = np.zeros(n)\ny = np.zeros(n)\nvx = np.zeros(n)\nx = np.zeros(n)\nyanalytic = np.zeros(n)\n# Initial conditions, note that these correspond to an object falling in the y-direction only.\nvx[0] = 0.0 #m/s\nvy[0] = 0.0 #m/s\ny[0] = 10.0 #m\nx[0] = 0.0 #m\nyanalytic[0] = y[0]\n# Start integrating using Euler's method\nfor i in range(n-1):\n # expression for acceleration, note the absolute value and division by mass\n# Note: you need to think of the sign for the drag force as function of the velocity vector \n ax = -D*vx[i]*sqrt(vx[i]**2+vy[i]**2)/m\n ay = -g - D*vy[i]*sqrt(vx[i]**2+vy[i]**2)/m\n # update velocity and position\n vx[i+1] = vx[i] + DeltaT*ax\n x[i+1] = x[i] + DeltaT*vx[i]\n vy[i+1] = vy[i] + DeltaT*ay\n y[i+1] = y[i] + DeltaT*vy[i]\n # update time to next time step and compute analytical answer\n t[i+1] = t[i] + DeltaT\n yanalytic[i+1] = y[0]-(vT*vT/g)*log(cosh(g*t[i+1]/vT))+vy[0]*t[i+1]\n if ( y[i+1] < 0.0):\n break\ndata = {'t[s]': t,\n 'Relative error in y': abs((y-yanalytic)/yanalytic),\n 'vy[m/s]': vy,\n 'x[m]': x,\n 'vx[m/s]': vx\n}\nNewData = pd.DataFrame(data)\ndisplay(NewData)\n# save to file\nNewData.to_csv(outfile, index=False)\n#then plot\nfig, axs = plt.subplots(4, 1)\naxs[0].plot(t, y)\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y')\naxs[1].plot(t, vy)\naxs[1].set_ylabel('vy[m/s]')\naxs[1].set_xlabel('time[s]')\naxs[2].plot(t, x)\naxs[2].set_xlim(0, tfinal)\naxs[2].set_ylabel('x')\naxs[3].plot(t, vx)\naxs[3].set_ylabel('vx[m/s]')\naxs[3].set_xlabel('time[s]')\nfig.tight_layout()\nsave_fig(\"EulerIntegration\")\nplt.show()\n```\n\n## A more compact version of the code\n\n\n```python\n# Exercise 6, hw3, smarter way with declaration of vx, vy, x and y\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\ng = 9.80655 #m/s^2 g to 6 leading digits after decimal point\nD = 0.00245 #m/s\nm = 0.2 # kg\n# Define Gravitational force as a vector in x and y. It is a constant\nG = -m*g*np.array([0.0,1])\nDeltaT = 0.01\n#set up arrays \ntfinal = 1.3\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and x\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions as compact 2-dimensional arrays\nr0 = np.array([0.0,10.0])\nv0 = np.array([10.0,0.0])\nr[0] = r0\nv[0] = v0\n# Start integrating using Euler's method\nfor i in range(n-1):\n # Set up forces, air resistance FD, note now that we need the norm of the vector\n # Here you could have defined your own function for this\n vabs = sqrt(sum(v[i]*v[i]))\n# Note: you need to think of the sign for the drag force \n FD = -D*v[i]*vabs\n # Final net forces acting on falling object\n Fnet = FD+G\n # The accelration at a given time t_i\n a = Fnet/m\n # update velocity, time and position using Euler's method\n v[i+1] = v[i] + DeltaT*a\n r[i+1] = r[i] + DeltaT*v[i]\n t[i+1] = t[i] + DeltaT\n\nfig, axs = plt.subplots(4, 1)\naxs[0].plot(t, r[:,1])\naxs[0].set_xlim(0, tfinal)\naxs[0].set_ylabel('y')\naxs[1].plot(t, v[:,1])\naxs[1].set_ylabel('vy[m/s]')\naxs[1].set_xlabel('time[s]')\naxs[2].plot(t, r[:,0])\naxs[2].set_xlim(0, tfinal)\naxs[2].set_ylabel('x')\naxs[3].plot(t, v[:,0])\naxs[3].set_ylabel('vx[m/s]')\naxs[3].set_xlabel('time[s]')\n\nfig.tight_layout()\nsave_fig(\"EulerIntegration\")\nplt.show()\n```\n", "meta": {"hexsha": "f56f6379dc493e6e5674158c0bbfbd1276e76995", "size": 57003, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/week5/ipynb/week5.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "doc/pub/week5/ipynb/week5.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "doc/pub/week5/ipynb/week5.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.3738178198, "max_line_length": 366, "alphanum_fraction": 0.5524095223, "converted": true, "num_tokens": 10209, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.341582499438317, "lm_q2_score": 0.3242353989809524, "lm_q1q2_score": 0.11075313799029365}}
{"text": "```python\n# %load ../../preconfig.py\n%matplotlib inline\nimport matplotlib.pyplot as plt\nplt.rcParams['axes.grid'] = False\nimport seaborn as sns\nsns.set(color_codes=True)\n\nimport numpy as np\nimport pandas as pd\n#import itertools\n\nimport sklearn\n\nimport logging\nlogger = logging.getLogger()\n```\n\nExercises\n=========\n\n### Ex 2.1\n##### Question\nSuppose each of K-classes has an associated target $t_k$, which is a vector of all zeros, except a one in the $k$th position. Show that classifying to the largest element of $\\hat{y}$ amounts to choosing the closest target, $\\min_k \\|tk − \\hat{y}\\|$, if the elements of $\\hat{y}$ sum to one.\n\n\n##### Solution\nGiven: \n$t_k = e_k$; \n$\\sum_i \\hat{y}_i = 1$.\n\nneed to proof: $\\text{arg max}_i \\hat{y}_i = \\text{arg min}_k \\|t_k - \\hat{y}\\|$.\n\nProof: \n\n\\begin{align}\n\\text{arg min}_k \\|t_k - \\hat{y}\\| &= \\text{arg min}_k \\left ( \\displaystyle \\sum_{j \\neq k} \\hat{y}_j + | \\hat{y}_k - 1 | \\right )\\\\\n &= \\text{arg min}_k \\left ( \\displaystyle \\sum_{j \\neq k} \\hat{y}_j + 1 - \\hat{y}_k \\right ) \\\\\n &= \\text{arg min}_k \\left ( 1 - \\hat{y}_k + 1 - \\hat{y}_k \\right ) \\\\\n &= \\text{arg min}_k 2(1 - \\hat{y}_k) \\\\\n &= \\text{arg max}_k \\hat{y}_k\n\\end{align}\n\n### Ex 2.2\n##### Question\nShow how to compute the Bayes decision boundary for the simula- tion example in Figure 2.5.\n\n\n##### Solution\n[ref: Elements of Statistical Learning - Andrew Tulloch](https://github.com/ajtulloch/Elements-of-Statistical-Learning/blob/master/ESL-Solutions.pdf)\n\nAs Eq.(2.22) of textbook:\n\\begin{align}\n \\hat{G}(x) &= \\text{arg min}_{g \\in \\mathcal{G}} [ 1 - P(g | X = x) ] \\\\\n &= \\text{arg max}_{g \\in \\mathcal{G}} P(g | X = x)\n\\end{align}\n\nThe optimal Bayes decision boundary is where:\n\\begin{align}\n P(\\text{orange} | X = x) &= P(\\text{blue} | X = x) \\\\\n \\frac{P( X = x | orange ) P( orange )}{P(X = x)} &= \\frac{P( X = x | blue ) P( blue )}{P(X = x)} \\\\\n P( X = x | orange ) P( orange ) &= P( X = x | blue ) P( blue )\n\\end{align}\n\nAs descriped in Sec 2.3.3, $P(orange)$ is same as $P(blue)$, and $P(X = x | orange)$ and $P(X = x | blue)$ are generated as bivariate Gassuian distribution. Hence we can work out the optimal Bayes decision boundary exactly.\n\n### Ex 2.3\n##### Question\nDerive equation (2.24).\n\nSuppose there are $N$ points, uniformly distributed in the unit sphere in $\\mathbb{R}^p$. What is the median distance from the origin to the closest data point? \n\n##### Solution\n[ref: Example Sheet 1: Solutions](http://www2.stat.duke.edu/~banks/cam-lectures.dir/Examples1-solns.pdf)\n\n(1)\nSuppose $r$ is the median distance from the origin to the closest data point.\n\nLet $r_{\\text{closest}}$ are all possible closetst points. \nBecause $r$ is the median case, $\\forall j$\n$$P(r_{\\text{closest}}^j \\geq r) = \\frac{1}{2}$$\n\nBecause $r_{\\text{closest}}^j$ is the closest point, so all $N$ points have distance $\\geq r_{\\text{closest}}^j \\geq r$. \n\ntogether, we get:\n$$P(\\text{all N points have distance } \\geq r) = \\frac{1}{2}$$\n\n(2)\nFirst, all points are uniformly distributed in the unit sphere in $\\mathbb{R}^p$. \n\nSecond, [the p-dimensional volume of a Euclidean ball of radius R in p-dimensional Euclidean space is](https://en.wikipedia.org/wiki/Volume_of_an_n-ball):\n$$V_p(R) = \\frac{\\pi^{p/2}}{\\Gamma(\\frac{p}{2} + 1)}R^p$$\n\ntogether, for any point $x$, \n\\begin{align}\nP(x \\text{ has distance } \\geq r) &= 1 - P(x \\text{ has distance } < r) \\\\\n &= 1 - \\frac{\\pi^{p/2}}{\\Gamma(\\frac{p}{2} + 1)}r^p \\Big{/} \\frac{\\pi^{p/2}}{\\Gamma(\\frac{p}{2} + 1)}1^p \n &= 1 - r^p\n\\end{align}\n\nThen:\n\\begin{align}\n P(\\text{all N points have distance } \\geq r) &= P^N (x \\text{ has distance } \\geq r) \\\\\n &= (1 - r^p)^N\n\\end{align}\n\n(3)\nIn all,\n$$\\frac{1}{2} = P(\\text{all N points have distance } \\geq r) = (1 - r^p)^N$$\n\nwe get the solution:\n$$r = (1 - (\\frac{1}{2})^{1/N})^{1/p}$$\n\n### Ex 2.4\n##### Question\nThe edge effect problem discussed on page 23 is not peculiar to uniform sampling from bounded domains. \n\nConsider inputs drawn from a spherical multinormal distribution $X \\sim N(0,I_p)$. The squared distance from any sample point to the origin has a $\\mathcal{X}^2_p$ distribution with mean $p$. Consider a prediction point $x_0$ drawn from this distribution, and let $a = x_0 \\big{/} \\| x0 \\|$ be an associated unit vector. Let $z_i = a^T x_i$ be the projection of each of the training points on this direction.\n\nShow that the $z_i$ are distributed $N(0,1)$ with expected squared distance from the origin 1, while the target point has expected squared distance $p$ from the origin.\n\n##### Solution\n$z_i = \\alpha^T x_i$, which is a linear combination. Moreover, $x_i \\sim N(0, I_p)$ means that its elements are all independant.\n\nAs [the variance of a linear combination](https://en.wikipedia.org/wiki/Variance#Sum_of_uncorrelated_variables_.28Bienaym.C3.A9_formula.29) is:\n$$\\operatorname{Var}\\left( \\sum_{i=1}^N a_iX_i\\right) = \\sum_{i=1}^N a_i^2\\operatorname{Var}(X_i)$$\n\nWe get:\n\\begin{align}\nE(z_i) &= \\alpha^T E(x_i) \\\\\n & = 0\n\\end{align}\nand\n\\begin{align}\n\\operatorname{Var} (z_i) &= \\sum \\alpha_j^2 \\operatorname{Var}(x_j^i) \\\\\n & = \\sum \\alpha_j^2 \\\\\n & = \\| \\alpha \\|^2_2 \\\\\n & = 1\n\\end{align}\n\nThus, $z_i \\sim N(0,1)$.\n\nThe target point has expected suqared distace $\\| x_i \\|_2^2 = p$.\n\n### Ex 2.5\n#### (a)\nDerive equation (2.27). The last line makes use of (3.8) through a conditioning argument. \n\n#### Solution\nFirst, we give:\n\n1. for $y_0 = x_0^T \\beta + \\epsilon; \\ \\epsilon \\sim N(0, \\sigma^2)$:\n + $E_{y_0 | x_0}(y_0) = E(y_0 | x_0) = E(x_0^T \\beta + \\epsilon) = x_0^T \\beta$\n + $\\operatorname{Var}_{y_0 | x_0}(y_0) = \\operatorname{Var}(y_0 | x_0) = \\operatorname{Var}(x_0^T \\beta + \\epsilon) = \\operatorname{Var}(\\epsilon) = \\sigma^2$\n\n2. for $\\hat{y}_0 = x_0^T \\hat{\\beta} = x_0^T \\beta + x_0 (X^T X)^{-1} x_0 \\epsilon$: \n + expected value:\n \\begin{equation}\n E_{\\tau}(\\hat{y_0}) = E(y_0 | x_0) = x_0^T \\beta \\quad \\text{unbiased}\n \\end{equation}\n + variance:\n \\begin{align}\n \\operatorname{Var}_{\\tau}(\\hat{y_0}) &= \\operatorname{Var}_{\\tau}(x_0^T \\hat{\\beta}) \\\\\n &= x_0^T \\operatorname{Var}_{\\tau}(\\hat{\\beta}) x_0 \\\\\n &= x_0^T E_{\\tau}((X^T X)^{-1} \\sigma^2) x_0 \\quad \\text{see Eq 3.8} \\\\\n &= E_{\\tau} x_0^T (X^T X)^{-1} x_0 \\sigma^2\n \\end{align}\n \n3. [Proof of variance and bias relationship](https://en.wikipedia.org/wiki/Mean_squared_error): \n\\begin{align}\n E( (\\hat{\\theta} - \\theta)^2 ) &= E( \\left (\\hat{\\theta} - E(\\hat{\\theta}) \\right )^2 ) + (E(\\hat{\\theta}) - \\theta)^ 2 \\\\\n &= \\operatorname{Var}(\\hat{\\theta}) + \\operatorname{Bias}^2 (\\hat{\\theta}, \\theta)\n\\end{align}\n\nThus, \n\\begin{align}\n \\operatorname{EPE}(x_0) &= E_{y_0 | x_0} E_{\\tau} (y_0 - \\hat{y}_0)^2 \\\\\n &= E_{\\tau} E_{\\color{blue}{y_0 | x_0}} (\\color{blue}{y_0} - \\hat{y}_0)^2 \\\\\n &= E_{\\tau} \\left ( \\operatorname{Var}(y_0 | x_0) + (E_{y_0 | x_0}(y_0) - \\hat{y}_0)^2 \\right ) \\\\\n &= \\operatorname{Var}(y_0 | x_0) + E_{\\color{blue}{\\tau}} \\left( E(y_0 | x_0) - \\color{blue}{\\hat{y}_0} \\right )^2 \\\\\n &= \\operatorname{Var}(y_0 | x_0) + \\operatorname{Var}_{\\tau}(\\hat{y}_0) + \\left ( E_{\\tau}(\\hat{y}_0) - E(y_0 | x_0) \\right)^2 \\\\\n &= \\operatorname{Var}(y_0 | x_0) + \\operatorname{Var}_{\\tau}(\\hat{y}_0) + \\left ( E_{\\tau}(\\hat{y}_0) - x_0^T \\beta \\right)^2 \\\\\n &= \\sigma^2 + E_{\\tau} x_0^T (X^T X)^{-1} x_0 \\sigma^2 + 0^2\n\\end{align}\n\n#### (b)\nDerive equation (2.28), making use of the cyclic property of the trace operator [trace(AB) = trace(BA)], and its linearity (which allows us to interchange the order of trace and expectation).\n\n\n#### Solution\n[ref: A Solution Manual and Notes for: The Elements of Statistical Learning by Jerome Friedman, Trevor Hastie, and Robert Tibshirani](https://www.google.com.sg/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwiF6sf2hsfLAhWSco4KHfJQCCwQFggbMAA&url=http%3A%2F%2Fwaxworksmath.com%2FAuthors%2FG_M%2FHastie%2FWriteUp%2Fweatherwax_epstein_hastie_solutions_manual.pdf&usg=AFQjCNH3VN6HgCDHtXNIbJtAjEEQNZFINA&sig2=b_zFhNYsupRwqtY62dGnwA)\n\n1. $x_0$ is $p \\times 1$ vector, and $\\mathbf{X}$ is $N \\times p$ matrix, hence $x_0^T (\\mathbf{X}^T \\mathbf{X})^{-1} x_0 = C_{1 \\times 1} = \\operatorname{trance}(C_{1 \\times 1})$\n\n2. [properity of Covariance matrix](https://en.wikipedia.org/wiki/Covariance_matrix) \n\\begin{align}\n \\operatorname{Cov}(x_0) &= E(x_0 x_0^T) - E(x_0) E(x_0)^T \\\\\n &= E(x_0 x_0^T) \\quad \\text{as } E(\\mathbf{X}) = 0 \\text{ and $x_0$ is picked randomly}\n\\end{align}\n\nThus,\n\\begin{align}\n E_{x_0} \\operatorname{EPE}(x_0) &= E_{x_0} x_0^T (\\mathbf{X}^T \\mathbf{X})^{-1} x_0 \\sigma^2 + \\sigma^2 \\\\\n &= E_{x_0} \\operatorname{trance} \\left ( x_0^T (\\mathbf{X}^T \\mathbf{X})^{-1} x_0 \\right ) \\sigma^2 + \\sigma^2 \\\\\n &= E_{x_0} \\operatorname{trance} \\left ( (\\mathbf{X}^T \\mathbf{X})^{-1} x_0 x_0^T \\right ) \\sigma^2 + \\sigma^2 \\quad \\text{cyclic property} \\\\\n &\\approx E_{x_0} \\operatorname{trance} \\left ( \\operatorname{Cov}^{-1}(\\mathbf{X}) x_0 x_0^T \\right ) \\frac{\\sigma^2}{N} + \\sigma^2 \\quad \\text{as } \\mathbf{X}^T \\mathbf{X} \\to N \\operatorname{Cov}(\\mathbf{X}) \\\\\n &= \\operatorname{trance} \\left ( \\operatorname{Cov}^{-1}(\\mathbf{X}) \\, E_{x_0}(x_0 x_0^T) \\right ) \\frac{\\sigma^2}{N} + \\sigma^2 \\quad \\text{linearity, interchange}\\\\\n &= \\operatorname{trance} \\left ( \\operatorname{Cov}^{-1}(\\mathbf{X}) \\, \\operatorname{Cov}(x_0) \\right ) \\frac{\\sigma^2}{N} + \\sigma^2 \\quad \\text{see 2. above}\\\\\n &= \\operatorname{trance} (I_p) \\frac{\\sigma^2}{N} + \\sigma^2 \\quad \\text{as } \\operatorname{Cov}(x_0) \\to \\operatorname{Cov}(\\mathbf{X}) \\\\\n &= p \\frac{\\sigma^2}{N} + \\sigma^2\n\\end{align}\n\n### Ex 2.6\n#### Question\nConsider a regression problem with inputs $x_i$ and outputs $y_i$, and a parameterized model $f_{\\theta}(x)$ to be fit by least squares. Show that if there are observations with tied or identical values of $x$, then the fit can be obtained from a reduced weighted least squares problem.\n\n#### Solution\n[ref: A Solution Manual and Notes for: The Elements of Statistical Learning by Jerome Friedman, Trevor Hastie, and Robert Tibshirani](https://www.google.com.sg/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=0ahUKEwiF6sf2hsfLAhWSco4KHfJQCCwQFggbMAA&url=http%3A%2F%2Fwaxworksmath.com%2FAuthors%2FG_M%2FHastie%2FWriteUp%2Fweatherwax_epstein_hastie_solutions_manual.pdf&usg=AFQjCNH3VN6HgCDHtXNIbJtAjEEQNZFINA&sig2=b_zFhNYsupRwqtY62dGnwA)\n\nAssume we have $N$ train samples, and let $N_u$ be the number of *unique* inputs $x$. And for $i$th unique $x_i$, the $y_i = \\{ y_{i,1}, y_{i,2}, \\dotsc, y_{i, n_i} \\} $, namely, consists of $n_i$ observation.\n\n\\begin{align}\n \\displaystyle \\operatorname{argmin}_{\\theta} \\sum_{k=1}^{N} (y_k - f_{\\theta}(x_k))^2 &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} \\sum_{j=1}^{n_i} (y_{ij} - f_{\\theta}(x_i))^2 \\\\\n &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} \\sum_{j=1}^{n_i} y_{ij}^2 - 2 f_{\\theta}(x_i) y_{ij} + f_{\\theta}(x_i)^2 \\\\\n &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} n_i \\left ( \\color{blue}{\\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij}^2} - 2 f_{\\theta}(x_i) \\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij} + f_{\\theta}(x_i)^2 \\right ) \\\\\n &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} n_i \\left ( \\color{red}{(\\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij})^2} - 2 f_{\\theta}(x_i) \\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij} + f_{\\theta}(x_i)^2 - \\color{red}{(\\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij})^2} + \\color{blue}{\\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij}^2} \\right ) \\\\\n &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} n_i \\left ( \\color{red}{\\bar{y}_i^2} - 2 f_{\\theta}(x_i) \\bar{y}_i^2 + f_{\\theta}(x_i)^2 - \\color{red}{\\bar{y}_i^2} + \\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij}^2 \\right ) \\quad \\text{def: } \\bar{y}_i = \\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij}\\\\\n &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} n_i \\left ( \\left ( \\bar{y}_i^2 - f_{\\theta}(x_i) \\right )^2 - \\bar{y}_i^2 + \\frac{1}{n_i} \\sum_{j=1}^{n_i} y_{ij}^2 \\right ) \\\\ \n &= \\operatorname{argmin}_{\\theta} \\left ( \\sum_{i=1}^{N_u} n_i \\left ( \\bar{y}_i^2 - f_{\\theta}(x_i) \\right )^2 - \\sum_{i=1}^{N_u} n_i \\bar{y}_i^2 + \\sum_{i=1}^{N_u} \\sum_{j=1}^{n_i} y_{ij}^2 \\right ) \\\\ \n &= \\operatorname{argmin}_{\\theta} \\left ( \\sum_{i=1}^{N_u} n_i \\left ( \\bar{y}_i^2 - f_{\\theta}(x_i) \\right )^2 + \\mathcal{C} \\right ) \\quad \\text{as $y_{ij}$ is fixed} \\\\ \n &= \\operatorname{argmin}_{\\theta} \\sum_{i=1}^{N_u} n_i \\left ( \\bar{y}_i^2 - f_{\\theta}(x_i) \\right )^2 \n\\end{align}\n\nThus, it's a *weighted* least squares as every $\\bar{y_i}$ is weighted by $n_i$. And also it is a *reduced* problem since $N_u < N$.\n\n### Ex 2.7\nSuppose we have a sample of $N$ pairs $x_i, y_i$ draw i.i.d from the distribution characterized as follows:\n\\begin{align}\n &x_i \\sim h(x), &\\text{the ddesign density} \\\\\n &y_i = f(x_i) + \\epsilon_i, &\\text{$f$ is the regression function} \\\\\n &\\epsilon_i \\sim (0, \\sigma^2), &\\text{mean zero, variance $\\sigma^2$}\n\\end{align}\n\nWe construct an estimator for $f$ *linear* in the $y_i$,\n$$\\hat{f}(x_0) = \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) y_i,$$ \nwhere the weights $\\ell_i(x_0; \\mathcal{X}$ do not depend on the $y_i$, but do depend on the entire training sequence of $x_i$, denoted here by $\\mathcal{X}$.\n\n#### (a) \nShow that linear regression and $k$-nearest-neighbor regression are mem- bers of this class of estimators. Describe explicitly the weights $\\ell_i(x_0; \\mathcal{X}$ in each of these cases.\n\n#### solution\n1. for linear regression \n $\\hat{\\beta} = (\\mathbf{X}^T \\mathbf{X})^{-1} \\mathbf{X}^T \\mathbf{y}$\n \n so:\n \\begin{align}\n \\hat{f}(x_0) &= x_0^T \\hat{\\beta} \\\\\n &= x_0^T (\\mathbf{X}^T \\mathbf{X})^{-1} \\mathbf{X}^T \\mathbf{y} \\\\\n &= \\displaystyle \\sum_{i=1}^N \\left [ x_0^T (\\mathbf{X}^T \\mathbf{X})^{-1} \\mathbf{X}^T \\right ]_i \\ y_i\n \\end{align}\n \n2. for neighbor model \n \\begin{align}\n \\hat{f}(x_0) &= \\frac{1}{k} \\displaystyle \\sum_{x_i \\in N_k(x_0)} y_i \\\\\n &= \\displaystyle \\sum_{i=1}^N \\frac{1}{k} \\ I(x_i \\in N_k(x_0)) \\ y_i\n \\end{align}\n\n#### (b)\nDecompose the conditional mean-squared error \n$$E_{\\mathcal{Y} | \\mathcal{X}} ( f(x_0) - \\hat{f}(x_0) )^2$$\ninto a conditional squared bias and a conditional variance component. Like $\\mathcal{X}$, $\\mathcal{Y}$ represents the entire training sequence of $y_i$.\n\n#### solution\n[ref:](https://en.wikipedia.org/wiki/Mean_squared_error)\nHere $\\mathcal{X}$ is fixed, and $\\mathcal{Y}$ varies. Also $x_0$ and $f(x_0)$ are fixed. \nso: \n\\begin{align}\nE_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0)) &= E_{\\mathcal{Y} | \\mathcal{X}} \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) y_i \\\\\n &= \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, E_{\\mathcal{Y} | \\mathcal{X}} ( y_i ) \\\\\n &= \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, E_{\\mathcal{Y} | \\mathcal{X}} ( f(x_i) + \\epsilon_i ) \\\\\n &= \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, \\left ( E_{\\mathcal{Y} | \\mathcal{X}} ( f(x_i) ) + E_{\\mathcal{Y} | \\mathcal{X}} ( \\epsilon_i ) \\right ) \\\\\n &= \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, E_{\\mathcal{Y} | \\mathcal{X}} ( f(x_i) ) \\\\\n &= \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, f(x_i) \\\\\n &= C \\quad \\text{constant when $\\mathcal{X}$ is fixed}\n\\end{align}\n\nThus:\n\n\\begin{align}\n {} & E_{\\mathcal{Y} | \\mathcal{X}} ( f(x_0) - \\hat{f}(x_0) )^2 \\\\\n = & E_{\\mathcal{Y} | \\mathcal{X}} ( \\hat{f}(x_0) - f(x_0) )^2 \\\\\n = & E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) + E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0) \\right )^2 \\\\\n = & E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right )^2 + 2 \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right ) \\left ( E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0) \\right ) + \\left ( E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0) \\right )^2 \\right ) \\\\\n = & E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right )^2 + E_{\\mathcal{Y} | \\mathcal{X}} 2 \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right ) \\left ( E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0) \\right ) + E_{\\mathcal{Y} | \\mathcal{X}} \\left ( E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0) \\right )^2 \\\\\n = & \\operatorname{Var}(\\hat{f}(x_0) + E_{\\mathcal{Y} | \\mathcal{X}} 2 \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right ) \\left ( \\underbrace{E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0)}_\\text{constant} \\right ) + \\color{blue}{E_{\\mathcal{Y} | \\mathcal{X}}} \\left ( \\underbrace{E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) - f(x_0)}_\\text{constant} \\right )^2 \\\\\n = & \\operatorname{Var}(\\hat{f}(x_0) + 2 \\left ( f(x_0) - C \\right ) \\, E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right ) + \\operatorname{Bias}^2 (\\hat{f}(x_0), f(x_0)) \\\\\n = & \\operatorname{Var}(\\hat{f}(x_0) + 2 \\left ( f(x_0) - C \\right ) \\, \\left ( E_{\\mathcal{Y} | \\mathcal{X}} \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0) \\right ) + \\operatorname{Bias}^2 (\\hat{f}(x_0), f(x_0)) \\\\\n = & \\operatorname{Var}(\\hat{f}(x_0) + \\operatorname{Bias}^2 (\\hat{f}(x_0), f(x_0)) \\\\\n\\end{align}\n\n#### (c)\nDecompose the (unconditional) mean-squared error \n$$E_{\\mathcal{Y}, \\mathcal{X}} ( f(x_0) - \\hat{f}(x_0) )^2$$\ninto a squared bias and a variance component. \n\n#### solution\n\\begin{align}\n {} & E_{\\mathcal{Y}, \\mathcal{X}} (f(x_0) - \\hat{f}(x_0))^2 \\\\\n = & E_{\\mathcal{X}} E_{\\mathcal{Y} | \\mathcal{X}} (f(x_0) - \\hat{f}(x_0))^2 \\\\\n\\end{align}\nuse similar method as above.\n\n#### (d)\nEstablish a relationship between the squared biases and variances in the above two cases.\n\n#### solution\n##### 1. for variance,\nAs we known in (b), \n$$E_{\\mathcal{Y} | \\mathcal{X}}(\\hat{f}(x_0)) = \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, f(x_i)$$\n\nand also:\n$$ \\hat{f}(x_0) = \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) y_i $$ \n$$ y_i = f(x_i) + \\epsilon_i $$\n\nThus,\n\\begin{align}\n \\operatorname{Var}(\\hat{f}(x_0)) &= E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\hat{f}(x_0) - E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\hat{f}(x_0) \\right ) \\right )^2 \\\\\n &= E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) y_i - \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, f(x_i) \\right )^2 \\\\\n &= E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\left ( y_i - f(x_i) \\right ) \\right )^2 \\\\\n &= E_{\\mathcal{Y} | \\mathcal{X}} \\left ( \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\epsilon_i \\right )^2 \\\\\n\\end{align}\n\n##### 2. for squared bias,\n\\begin{align}\n \\operatorname{Bias}^2 (\\hat{f}(x_0), f(x_0)) &= \\left ( E_{\\mathcal{Y} | \\mathcal{X}} \\hat{f}(x_0) - f(x_0) \\right )^2 \\\\\n &= \\left( \\displaystyle \\sum_{i=1}^N \\ell_i(x_0; \\mathcal{X}) \\, f(x_i) - f(x_0) \\right )^2 \\\\\n\\end{align}\n\n##### 3. guess\nvariance is only affected by $\\epsilon$, while squared bias is only affected by $f(x)$. Because $\\epsilon$ is independent with $f(x)$, it might not possible that there is a relation between variance and squared bias. \n\n### Ex 2.8\nCompare the classification performance of linear regression and $k$-nearest neighbor classification on the zipcode data. In particular, consider only the 2’s and 3’s, and $k$ = 1, 3, 5, 7 and 15. Show both the training and test error for each choice. The zipcode data are available from the book website www-stat.stanford.edu/ElemStatLearn.\n\n\n```python\ntrain_dat = pd.read_csv('./res/zip.train', header=None, sep=' ')\ntrain_dat.rename(columns={0: 'digital'}, inplace=True)\ntrain_dat = train_dat.query('digital == 2 or digital == 3')\ntrain_dat.dropna(axis=1, inplace=True)\n```\n\n\n```python\ntrain_dat.set_index('digital', inplace=True)\n```\n\n\n```python\ntrain_dat.head(3)\n```\n\n\n\n\n\n
\n \n \n 1 \n 2 \n 3 \n 4 \n 5 \n 6 \n 7 \n 8 \n 9 \n 10 \n ... \n 247 \n 248 \n 249 \n 250 \n 251 \n 252 \n 253 \n 254 \n 255 \n 256 \n \n \n digital \n \n \n \n \n 3 \n -1 \n -1 \n -1 \n -1.00 \n -1.000 \n -0.928 \n -0.204 \n 0.751 \n 0.466 \n 0.234 \n ... \n 0.466 \n 0.639 \n 1.000 \n 1.000 \n 0.791 \n 0.439 \n -0.199 \n -0.883 \n -1 \n -1 \n \n \n 3 \n -1 \n -1 \n -1 \n -0.83 \n 0.442 \n 1.000 \n 1.000 \n 0.479 \n -0.328 \n -0.947 \n ... \n 1.000 \n 0.671 \n 0.345 \n -0.507 \n -1.000 \n -1.000 \n -1.000 \n -1.000 \n -1 \n -1 \n \n \n 3 \n -1 \n -1 \n -1 \n -1.00 \n -1.000 \n -0.104 \n 0.549 \n 0.579 \n 0.579 \n 0.857 \n ... \n 0.388 \n 0.579 \n 0.811 \n 1.000 \n 1.000 \n 0.715 \n 0.107 \n -0.526 \n -1 \n -1 \n \n \n
\n
3 rows × 256 columns
\n
\n
\n \n \n 1 \n 2 \n 3 \n 4 \n 5 \n 6 \n 7 \n 8 \n 9 \n 10 \n ... \n 247 \n 248 \n 249 \n 250 \n 251 \n 252 \n 253 \n 254 \n 255 \n 256 \n \n \n digital \n \n \n \n \n 3 \n -1.000 \n -1.000 \n -1.000 \n -0.593 \n 0.700 \n 1.000 \n 1.000 \n 1.000 \n 1.000 \n 0.853 \n ... \n 1.000 \n 0.717 \n 0.333 \n 0.162 \n -0.393 \n -1.000 \n -1 \n -1 \n -1 \n -1 \n \n \n 2 \n -0.996 \n 0.572 \n 0.396 \n 0.063 \n -0.506 \n -0.847 \n -1.000 \n -1.000 \n -1.000 \n -1.000 \n ... \n -0.668 \n -1.000 \n -1.000 \n -1.000 \n -1.000 \n -1.000 \n -1 \n -1 \n -1 \n -1 \n \n \n 2 \n -1.000 \n -1.000 \n 0.469 \n 0.413 \n 1.000 \n 1.000 \n 0.462 \n -0.116 \n -0.937 \n -1.000 \n ... \n 1.000 \n 1.000 \n 1.000 \n 0.270 \n -0.280 \n -0.855 \n -1 \n -1 \n -1 \n -1 \n \n \n
\n
3 rows × 256 columns
\n
Figure 1:
\n\n\n\n## Repetition from last week: Work, Energy, Momentum and Conservation laws\n\nEnergy conservation is most convenient as a strategy for addressing\nproblems where time does not appear. For example, a particle goes\nfrom position $x_0$ with speed $v_0$, to position $x_f$; what is its\nnew speed? However, it can also be applied to problems where time\ndoes appear, such as in solving for the trajectory $x(t)$, or\nequivalently $t(x)$.\n\n\n\n\n## Energy Conservation\nEnergy is conserved in the case where the potential energy, $V(\\boldsymbol{r})$, depends only on position, and not on time. The force is determined by $V$,\n\n\n
\n\n$$\n\\begin{equation}\n\\boldsymbol{F}(\\boldsymbol{r})=-\\boldsymbol{\\nabla} V(\\boldsymbol{r}).\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\n## Conservative forces\n\nWe say a force is conservative if it satisfies the following conditions:\n1. The force $\\boldsymbol{F}$ acting on an object only depends on the position $\\boldsymbol{r}$, that is $\\boldsymbol{F}=\\boldsymbol{F}(\\boldsymbol{r})$.\n\n2. For any two points $\\boldsymbol{r}_1$ and $\\boldsymbol{r}_2$, the work done by the force $\\boldsymbol{F}$ on the displacement between these two points is independent of the path taken.\n\n3. Finally, the **curl** of the force is zero $\\boldsymbol{\\nabla}\\times\\boldsymbol{F}=0$.\n\n## Forces and Potentials\n\nThe energy $E$ of a given system is defined as the sum of kinetic and potential energies,\n\n$$\nE=K+V(\\boldsymbol{r}).\n$$\n\nWe define the potential energy at a point $\\boldsymbol{r}$ as the negative work done from a starting point $\\boldsymbol{r}_0$ to a final point $\\boldsymbol{r}$\n\n$$\nV(\\boldsymbol{r})=-W(\\boldsymbol{r}_0\\rightarrow\\boldsymbol{r})= -\\int_{\\boldsymbol{r}_0}^{\\boldsymbol{r}}d\\boldsymbol{r}'\\boldsymbol{F}(\\boldsymbol{r}').\n$$\n\nIf the potential depends on the path taken between these two points there is no unique potential.\n\n\n## Example (relevant for homework 5)\n\nWe study a classical electron which moves in the $x$-direction along a surface. The force from the surface is\n\n$$\n\\boldsymbol{F}(x)=-F_0\\sin{(\\frac{2\\pi x}{b})}\\boldsymbol{e}_1.\n$$\n\nThe constant $b$ represents the distance between atoms at the surface of the material, $F_0$ is a constant and $x$ is the position of the electron.\n\nThis is indeed a conservative force since it depends only on position\nand its **curl** is zero, that is $-\\boldsymbol{\\nabla}\\times \\boldsymbol{F}=0$. This means that energy is conserved and the\nintegral over the work done by the force is independent of the path\ntaken. We will come back to this in more detail next week.\n\n## Example Continues\n\n\nUsing the work-energy theorem we can find the work $W$ done when\nmoving an electron from a position $x_0$ to a final position $x$\nthrough the integral\n\n$$\nW=-\\int_{x_0}^x \\boldsymbol{F}(x')dx' = \\int_{x_0}^x F_0\\sin{(\\frac{2\\pi x'}{b})} dx',\n$$\n\nwhich results in\n\n$$\nW=\\frac{F_0b}{2\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-\\cos{(\\frac{2\\pi x_0}{b})}\\right].\n$$\n\nSince this is related to the change in kinetic energy we have, with $v_0$ being the initial velocity at a time $t_0$,\n\n$$\nv = \\pm\\sqrt{\\frac{2}{m}\\frac{F_0b}{2\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-\\cos{(\\frac{2\\pi x_0}{b})}\\right]+v_0^2}.\n$$\n\n## The potential energy from this example\n\nThe potential energy, due to energy conservation is\n\n$$\nV(x)=V(x_0)+\\frac{1}{2}mv_0^2-\\frac{1}{2}mv^2,\n$$\n\nwith $v$ given by the velocity from above.\n\nWe can now, in order to find a more explicit expression for the\npotential energy at a given value $x$, define a zero level value for\nthe potential. The potential is defined, using the work-energy\ntheorem, as\n\n$$\nV(x)=V(x_0)+\\int_{x_0}^x (-F(x'))dx',\n$$\n\nand if you recall the definition of the indefinite integral, we can rewrite this as\n\n$$\nV(x)=\\int (-F(x'))dx'+C,\n$$\n\nwhere $C$ is an undefined constant. The force is defined as the\ngradient of the potential, and in that case the undefined constant\nvanishes. The constant does not affect the force we derive from the\npotential.\n\nWe have then\n\n$$\nV(x)=V(x_0)-\\int_{x_0}^x \\boldsymbol{F}(x')dx',\n$$\n\nwhich results in\n\n$$\nV(x)=\\frac{F_0b}{2\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}-\\cos{(\\frac{2\\pi x_0}{b})}\\right]+V(x_0).\n$$\n\nWe can now define\n\n$$\n\\frac{F_0b}{2\\pi}\\cos{(\\frac{2\\pi x_0}{b})}=V(x_0),\n$$\n\nwhich gives\n\n$$\nV(x)=\\frac{F_0b}{2\\pi}\\left[\\cos{(\\frac{2\\pi x}{b})}\\right].\n$$\n\n## Force and Potential\n\nWe have defined work as the energy resulting from a net force acting\non an object (or sseveral objects), that is\n\n$$\nW(\\boldsymbol{r}\\rightarrow \\boldsymbol{r}+d\\boldsymbol{r})= \\boldsymbol{F}(\\boldsymbol{r})d\\boldsymbol{r}.\n$$\n\nIf we write out this for each component we have\n\n$$\nW(\\boldsymbol{r}\\rightarrow \\boldsymbol{r}+d\\boldsymbol{r})=\\boldsymbol{F}(\\boldsymbol{r})d\\boldsymbol{r}=F_xdx+F_ydy+F_zdz.\n$$\n\nThe work done from an initial position to a final one defines also the difference in potential energies\n\n$$\nW(\\boldsymbol{r}\\rightarrow \\boldsymbol{r}+d\\boldsymbol{r})=-\\left[V(\\boldsymbol{r}+d\\boldsymbol{r})-V(\\boldsymbol{r})\\right].\n$$\n\n## Getting to $\\boldsymbol{F}(\\boldsymbol{r})=-\\boldsymbol{\\nabla} V(\\boldsymbol{r})$\n\nWe can write out the differences in potential energies as\n\n$$\nV(\\boldsymbol{r}+d\\boldsymbol{r})-V(\\boldsymbol{r})=V(x+dx,y+dy,z+dz)-V(x,y,z)=dV,\n$$\n\nand using the expression the differential of a multi-variable function $f(x,y,z)$\n\n$$\ndf=\\frac{\\partial f}{\\partial x}dx+\\frac{\\partial f}{\\partial y}dy+\\frac{\\partial f}{\\partial z}dz,\n$$\n\nwe can write the expression for the work done as\n\n$$\nW(\\boldsymbol{r}\\rightarrow \\boldsymbol{r}+d\\boldsymbol{r})=-dV=-\\left[\\frac{\\partial V}{\\partial x}dx+\\frac{\\partial V}{\\partial y}dy+\\frac{\\partial V}{\\partial z}dz \\right].\n$$\n\n## Final expression\n\nComparing the last equation with\n\n$$\nW(\\boldsymbol{r}\\rightarrow \\boldsymbol{r}+d\\boldsymbol{r})=F_xdx+F_ydy+F_zdz,\n$$\n\nwe have\n\n$$\nF_xdx+F_ydy+F_zdz=-\\left[\\frac{\\partial V}{\\partial x}dx+\\frac{\\partial V}{\\partial y}dy+\\frac{\\partial V}{\\partial z}dz \\right],\n$$\n\nleading to\n\n$$\nF_x=-\\frac{\\partial V}{\\partial x},\n$$\n\nand\n\n$$\nF_y=-\\frac{\\partial V}{\\partial y},\n$$\n\nand\n\n$$\nF_z=-\\frac{\\partial V}{\\partial z},\n$$\n\nor just\n\n$$\n\\boldsymbol{F}=-\\frac{\\partial V}{\\partial x}\\boldsymbol{e}_1-\\frac{\\partial V}{\\partial y}\\boldsymbol{e}_2-\\frac{\\partial V}{\\partial z}\\boldsymbol{e}_3=-\\boldsymbol{\\nabla}V(\\boldsymbol{r}).\n$$\n\nAnd this connection is the one we wanted to show.\n\n\n## Net Energy\n\nThe net energy, $E=V+K$ where $K$ is the kinetic energy, is then conserved,\n\n$$\n\\begin{eqnarray}\n\\frac{d}{dt}(K+V)&=&\\frac{d}{dt}\\left(\\frac{m}{2}(v_x^2+v_y^2+v_z^2)+V(\\boldsymbol{r})\\right)\\\\\n\\nonumber\n&=&m\\left(v_x\\frac{dv_x}{dt}+v_y\\frac{dv_y}{dt}+v_z\\frac{dv_z}{dt}\\right)\n+\\partial_xV\\frac{dx}{dt}+\\partial_yV\\frac{dy}{dt}+\\partial_zV\\frac{dz}{dt}\\\\\n\\nonumber\n&=&v_xF_x+v_yF_y+v_zF_z-F_xv_x-F_yv_y-F_zv_z=0.\n\\end{eqnarray}\n$$\n\n## In Vector Notation\n\nThe same proof can be written more compactly with vector notation,\n\n$$\n\\begin{eqnarray}\n\\frac{d}{dt}\\left(\\frac{m}{2}v^2+V(\\boldsymbol{r})\\right)\n&=&m\\boldsymbol{v}\\cdot\\dot{\\boldsymbol{v}}+\\boldsymbol{\\nabla} V(\\boldsymbol{r})\\cdot\\dot{\\boldsymbol{r}}\\\\\n\\nonumber\n&=&\\boldsymbol{v}\\cdot\\boldsymbol{F}-\\boldsymbol{F}\\cdot\\boldsymbol{v}=0.\n\\end{eqnarray}\n$$\n\nInverting the expression for kinetic energy,\n\n\n
\n\n$$\n\\begin{equation}\nv=\\sqrt{2K/m}=\\sqrt{2(E-V)/m},\n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\nallows one to solve for the one-dimensional trajectory $x(t)$, by finding $t(x)$,\n\n\n
\n\n$$\n\\begin{equation}\nt=\\int_{x_0}^x \\frac{dx'}{v(x')}=\\int_{x_0}^x\\frac{dx'}{\\sqrt{2(E-V(x'))/m}}.\n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\nNote this would be much more difficult in higher dimensions, because\nyou would have to determine which points, $x,y,z$, the particles might\nreach in the trajectory, whereas in one dimension you can typically\ntell by simply seeing whether the kinetic energy is positive at every\npoint between the old position and the new position.\n\n\n## Harmonic Oscillator Potential\n\n\nConsider a simple harmonic oscillator potential, $V(x)=kx^2/2$, with a particle emitted from $x=0$ with velocity $v_0$. Solve for the trajectory $t(x)$,\n\n$$\n\\begin{eqnarray}\nt&=&\\int_{0}^x \\frac{dx'}{\\sqrt{2(E-kx^2/2)/m}}\\\\\n\\nonumber\n&=&\\sqrt{m/k}\\int_0^x~\\frac{dx'}{\\sqrt{x_{\\rm max}^2-x^{\\prime 2}}},~~~x_{\\rm max}^2=2E/k.\n\\end{eqnarray}\n$$\n\nHere $E=mv_0^2/2$ and $x_{\\rm max}$ is defined as the maximum\ndisplacement before the particle turns around. This integral is done\nby the substitution $\\sin\\theta=x/x_{\\rm max}$.\n\n$$\n\\begin{eqnarray}\n(k/m)^{1/2}t&=&\\sin^{-1}(x/x_{\\rm max}),\\\\\n\\nonumber\nx&=&x_{\\rm max}\\sin\\omega t,~~~\\omega=\\sqrt{k/m}.\n\\end{eqnarray}\n$$\n\n## The Earth-Sun system\n\nWe will now venture into a study of a system which is energy\nconserving. The aim is to see if we (since it is not possible to solve\nthe general equations analytically) we can develop stable numerical\nalgorithms whose results we can trust!\n\nWe solve the equations of motion numerically. We will also compute\nquantities like the energy numerically.\n\nWe start with a simpler case first, the Earth-Sun system in two dimensions only. The gravitational force $F_G$ on the earth from the sun is\n\n$$\n\\boldsymbol{F}_G=-\\frac{GM_{\\odot}M_E}{r^3}\\boldsymbol{r},\n$$\n\nwhere $G$ is the gravitational constant,\n\n$$\nM_E=6\\times 10^{24}\\mathrm{Kg},\n$$\n\nthe mass of Earth,\n\n$$\nM_{\\odot}=2\\times 10^{30}\\mathrm{Kg},\n$$\n\nthe mass of the Sun and\n\n$$\nr=1.5\\times 10^{11}\\mathrm{m},\n$$\n\nis the distance between Earth and the Sun. The latter defines what we call an astronomical unit **AU**.\n\n\n## The Earth-Sun system, Newton's Laws\n\nFrom Newton's second law we have then for the $x$ direction\n\n$$\n\\frac{d^2x}{dt^2}=-\\frac{F_{x}}{M_E},\n$$\n\nand\n\n$$\n\\frac{d^2y}{dt^2}=-\\frac{F_{y}}{M_E},\n$$\n\nfor the $y$ direction.\n\nHere we will use that $x=r\\cos{(\\theta)}$, $y=r\\sin{(\\theta)}$ and\n\n$$\nr = \\sqrt{x^2+y^2}.\n$$\n\nWe can rewrite\n\n$$\nF_{x}=-\\frac{GM_{\\odot}M_E}{r^2}\\cos{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}x,\n$$\n\nand\n\n$$\nF_{y}=-\\frac{GM_{\\odot}M_E}{r^2}\\sin{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}y,\n$$\n\nfor the $y$ direction.\n\n## The Earth-Sun system, rewriting the Equations\n\nWe can rewrite these two equations\n\n$$\nF_{x}=-\\frac{GM_{\\odot}M_E}{r^2}\\cos{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}x,\n$$\n\nand\n\n$$\nF_{y}=-\\frac{GM_{\\odot}M_E}{r^2}\\sin{(\\theta)}=-\\frac{GM_{\\odot}M_E}{r^3}y,\n$$\n\nas four first-order coupled differential equations\n\n4\n3\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n4\n4\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n4\n5\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n$$\n\\frac{dy}{dt}=v_y.\n$$\n\n## Building a code for the solar system, final coupled equations\n\nThe four coupled differential equations\n\n4\n7\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n4\n8\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n4\n9\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n$$\n\\frac{dy}{dt}=v_y,\n$$\n\ncan be turned into dimensionless equations or we can introduce astronomical units with $1$ AU = $1.5\\times 10^{11}$. \n\nUsing the equations from circular motion (with $r =1\\mathrm{AU}$)\n\n$$\n\\frac{M_E v^2}{r} = F = \\frac{GM_{\\odot}M_E}{r^2},\n$$\n\nwe have\n\n$$\nGM_{\\odot}=v^2r,\n$$\n\nand using that the velocity of Earth (assuming circular motion) is\n$v = 2\\pi r/\\mathrm{yr}=2\\pi\\mathrm{AU}/\\mathrm{yr}$, we have\n\n$$\nGM_{\\odot}= v^2r = 4\\pi^2 \\frac{(\\mathrm{AU})^3}{\\mathrm{yr}^2}.\n$$\n\n## Building a code for the solar system, discretized equations\n\nThe four coupled differential equations can then be discretized using Euler's method as (with step length $h$)\n\n5\n4\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n5\n5\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n5\n6\n \n<\n<\n<\n!\n!\nM\nA\nT\nH\n_\nB\nL\nO\nC\nK\n\n$$\ny_{i+1}=y_i+hv_{y,i},\n$$\n\n## Code Example with Euler's Method\n\nThe code here implements Euler's method for the Earth-Sun system using a more compact way of representing the vectors. Alternatively, you could have spelled out all the variables $v_x$, $v_y$, $x$ and $y$ as one-dimensional arrays.\n\n\n```python\n%matplotlib inline\n\n# Common imports\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nimport os\n\n# Where to save the figures and data files\nPROJECT_ROOT_DIR = \"Results\"\nFIGURE_ID = \"Results/FigureFiles\"\nDATA_ID = \"DataFiles/\"\n\nif not os.path.exists(PROJECT_ROOT_DIR):\n os.mkdir(PROJECT_ROOT_DIR)\n\nif not os.path.exists(FIGURE_ID):\n os.makedirs(FIGURE_ID)\n\nif not os.path.exists(DATA_ID):\n os.makedirs(DATA_ID)\n\ndef image_path(fig_id):\n return os.path.join(FIGURE_ID, fig_id)\n\ndef data_path(dat_id):\n return os.path.join(DATA_ID, dat_id)\n\ndef save_fig(fig_id):\n plt.savefig(image_path(fig_id) + \".png\", format='png')\n\n\nDeltaT = 0.001\n#set up arrays \ntfinal = 10 # in years\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and x\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions as compact 2-dimensional arrays\nr0 = np.array([1.0,0.0])\nv0 = np.array([0.0,2*pi])\nr[0] = r0\nv[0] = v0\nFourpi2 = 4*pi*pi\n# Start integrating using Euler's method\nfor i in range(n-1):\n # Set up the acceleration\n # Here you could have defined your own function for this\n rabs = sqrt(sum(r[i]*r[i]))\n a = -Fourpi2*r[i]/(rabs**3)\n # update velocity, time and position using Euler's forward method\n v[i+1] = v[i] + DeltaT*a\n r[i+1] = r[i] + DeltaT*v[i]\n t[i+1] = t[i] + DeltaT\n# Plot position as function of time \nfig, ax = plt.subplots()\n#ax.set_xlim(0, tfinal)\nax.set_ylabel('x[m]')\nax.set_xlabel('y[m]')\nax.plot(r[:,0], r[:,1])\nfig.tight_layout()\nsave_fig(\"EarthSunEuler\")\nplt.show()\n```\n\n## Problems with Euler's Method\n\nWe notice here that Euler's method doesn't give a stable orbit. It\nmeans that we cannot trust Euler's method. In a deeper way, as we will\nsee in homework 5, Euler's method does not conserve energy. It is an\nexample of an integrator which is not\n[symplectic](https://en.wikipedia.org/wiki/Symplectic_integrator).\n\nHere we present thus two methods, which with simple changes allow us to avoid these pitfalls. The simplest possible extension is the so-called Euler-Cromer method.\nThe changes we need to make to our code are indeed marginal here.\nWe need simply to replace\n\n\n```python\n r[i+1] = r[i] + DeltaT*v[i]\n```\n\nin the above code with the velocity at the new time $t_{i+1}$\n\n\n```python\n r[i+1] = r[i] + DeltaT*v[i+1]\n```\n\nBy this simple caveat we get stable orbits.\nBelow we derive the Euler-Cromer method as well as one of the most utlized algorithms for sovling the above type of problems, the so-called Velocity-Verlet method. \n\n## Deriving the Euler-Cromer Method\n\nLet us repeat Euler's method.\nWe have a differential equation\n\n\n
\n\n$$\n\\begin{equation}\ny'(t_i)=f(t_i,y_i) \n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\nand if we truncate at the first derivative, we have from the Taylor expansion\n\n\n
\n\n$$\n\\begin{equation}\ny_{i+1}=y(t_i) + (\\Delta t) f(t_i,y_i) + O(\\Delta t^2), \\label{eq:euler} \\tag{5}\n\\end{equation}\n$$\n\nwhich when complemented with $t_{i+1}=t_i+\\Delta t$ forms\nthe algorithm for the well-known Euler method. \nNote that at every step we make an approximation error\nof the order of $O(\\Delta t^2)$, however the total error is the sum over all\nsteps $N=(b-a)/(\\Delta t)$ for $t\\in [a,b]$, yielding thus a global error which goes like\n$NO(\\Delta t^2)\\approx O(\\Delta t)$. \n\nTo make Euler's method more precise we can obviously\ndecrease $\\Delta t$ (increase $N$), but this can lead to loss of numerical precision.\nEuler's method is not recommended for precision calculation,\nalthough it is handy to use in order to get a first\nview on how a solution may look like.\n\nEuler's method is asymmetric in time, since it uses information about the derivative at the beginning\nof the time interval. This means that we evaluate the position at $y_1$ using the velocity\nat $v_0$. A simple variation is to determine $x_{n+1}$ using the velocity at\n$v_{n+1}$, that is (in a slightly more generalized form)\n\n\n
\n\n$$\n\\begin{equation} \ny_{n+1}=y_{n}+ v_{n+1}+O(\\Delta t^2)\n\\label{_auto5} \\tag{6}\n\\end{equation}\n$$\n\nand\n\n\n
\n\n$$\n\\begin{equation}\nv_{n+1}=v_{n}+(\\Delta t) a_{n}+O(\\Delta t^2).\n\\label{_auto6} \\tag{7}\n\\end{equation}\n$$\n\nThe acceleration $a_n$ is a function of $a_n(y_n, v_n, t_n)$ and needs to be evaluated\nas well. This is the Euler-Cromer method.\n\n**Exercise**: go back to the above code with Euler's method and add the Euler-Cromer method. \n\n\n## Deriving the Velocity-Verlet Method\n\nLet us stay with $x$ (position) and $v$ (velocity) as the quantities we are interested in.\n\nWe have the Taylor expansion for the position given by\n\n$$\nx_{i+1} = x_i+(\\Delta t)v_i+\\frac{(\\Delta t)^2}{2}a_i+O((\\Delta t)^3).\n$$\n\nThe corresponding expansion for the velocity is\n\n$$\nv_{i+1} = v_i+(\\Delta t)a_i+\\frac{(\\Delta t)^2}{2}v^{(2)}_i+O((\\Delta t)^3).\n$$\n\nVia Newton's second law we have normally an analytical expression for the derivative of the velocity, namely\n\n$$\na_i= \\frac{d^2 x}{dt^2}\\vert_{i}=\\frac{d v}{dt}\\vert_{i}= \\frac{F(x_i,v_i,t_i)}{m}.\n$$\n\nIf we add to this the corresponding expansion for the derivative of the velocity\n\n$$\nv^{(1)}_{i+1} = a_{i+1}= a_i+(\\Delta t)v^{(2)}_i+O((\\Delta t)^2)=a_i+(\\Delta t)v^{(2)}_i+O((\\Delta t)^2),\n$$\n\nand retain only terms up to the second derivative of the velocity since our error goes as $O(h^3)$, we have\n\n$$\n(\\Delta t)v^{(2)}_i\\approx a_{i+1}-a_i.\n$$\n\nWe can then rewrite the Taylor expansion for the velocity as\n\n$$\nv_{i+1} = v_i+\\frac{(\\Delta t)}{2}\\left( a_{i+1}+a_{i}\\right)+O((\\Delta t)^3).\n$$\n\n## The velocity Verlet method\n\nOur final equations for the position and the velocity become then\n\n$$\nx_{i+1} = x_i+(\\Delta t)v_i+\\frac{(\\Delta t)^2}{2}a_{i}+O((\\Delta t)^3),\n$$\n\nand\n\n$$\nv_{i+1} = v_i+\\frac{(\\Delta t)}{2}\\left(a_{i+1}+a_{i}\\right)+O((\\Delta t)^3).\n$$\n\nNote well that the term $a_{i+1}$ depends on the position at $x_{i+1}$. This means that you need to calculate \nthe position at the updated time $t_{i+1}$ before the computing the next velocity. Note also that the derivative of the velocity at the time\n$t_i$ used in the updating of the position can be reused in the calculation of the velocity update as well. \n\n\n## Adding the Velocity-Verlet Method\n\nWe can now easily add the Verlet method to our original code as\n\n\n```python\nDeltaT = 0.01\n#set up arrays \ntfinal = 10\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, a, v, and x\nt = np.zeros(n)\nv = np.zeros((n,2))\nr = np.zeros((n,2))\n# Initial conditions as compact 2-dimensional arrays\nr0 = np.array([1.0,0.0])\nv0 = np.array([0.0,2*pi])\nr[0] = r0\nv[0] = v0\nFourpi2 = 4*pi*pi\n# Start integrating using the Velocity-Verlet method\nfor i in range(n-1):\n # Set up forces, air resistance FD, note now that we need the norm of the vecto\n # Here you could have defined your own function for this\n rabs = sqrt(sum(r[i]*r[i]))\n a = -Fourpi2*r[i]/(rabs**3)\n # update velocity, time and position using the Velocity-Verlet method\n r[i+1] = r[i] + DeltaT*v[i]+0.5*(DeltaT**2)*a\n rabs = sqrt(sum(r[i+1]*r[i+1]))\n anew = -4*(pi**2)*r[i+1]/(rabs**3)\n v[i+1] = v[i] + 0.5*DeltaT*(a+anew)\n t[i+1] = t[i] + DeltaT\n# Plot position as function of time \nfig, ax = plt.subplots()\nax.set_ylabel('x[m]')\nax.set_xlabel('y[m]')\nax.plot(r[:,0], r[:,1])\nfig.tight_layout()\nsave_fig(\"EarthSunVV\")\nplt.show()\n```\n\nYou can easily generalize the calculation of the forces by defining a function\nwhich takes in as input the various variables. We leave this as a challenge to you.\n\n\n\n\n## Harmonic Oscillator\n\nThe harmonic oscillator is omnipresent in physics. Although you may think \nof this as being related to springs, it, or an equivalent\nmathematical representation, appears in just about any problem where a\nmode is sitting near its potential energy minimum. At that point,\n$\\partial_x V(x)=0$, and the first non-zero term (aside from a\nconstant) in the potential energy is that of a harmonic oscillator. In\na solid, sound modes (phonons) are built on a picture of coupled\nharmonic oscillators, and in relativistic field theory the fundamental\ninteractions are also built on coupled oscillators positioned\ninfinitesimally close to one another in space. The phenomena of a\nresonance of an oscillator driven at a fixed frequency plays out\nrepeatedly in atomic, nuclear and high-energy physics, when quantum\nmechanically the evolution of a state oscillates according to\n$e^{-iEt}$ and exciting discrete quantum states has very similar\nmathematics as exciting discrete states of an oscillator.\n\n\n## Harmonic Oscillator, deriving the Equations\nThe potential energy for a single particle as a function of its position $x$ can be written as a Taylor expansion about some point $x_0$\n\n\n
\n\n$$\n\\begin{equation}\nV(x)=V(x_0)+(x-x_0)\\left.\\partial_xV(x)\\right|_{x_0}+\\frac{1}{2}(x-x_0)^2\\left.\\partial_x^2V(x)\\right|_{x_0}\n+\\frac{1}{3!}\\left.\\partial_x^3V(x)\\right|_{x_0}+\\cdots\n\\label{_auto7} \\tag{8}\n\\end{equation}\n$$\n\nIf the position $x_0$ is at the minimum of the resonance, the first two non-zero terms of the potential are\n\n$$\n\\begin{eqnarray}\nV(x)&\\approx& V(x_0)+\\frac{1}{2}(x-x_0)^2\\left.\\partial_x^2V(x)\\right|_{x_0},\\\\\n\\nonumber\n&=&V(x_0)+\\frac{1}{2}k(x-x_0)^2,~~~~k\\equiv \\left.\\partial_x^2V(x)\\right|_{x_0},\\\\\n\\nonumber\nF&=&-\\partial_xV(x)=-k(x-x_0).\n\\end{eqnarray}\n$$\n\nPut into Newton's 2nd law (assuming $x_0=0$),\n\n$$\n\\begin{eqnarray}\nm\\ddot{x}&=&-kx,\\\\\nx&=&A\\cos(\\omega_0 t-\\phi),~~~\\omega_0=\\sqrt{k/m}.\n\\end{eqnarray}\n$$\n\n## Harmonic Oscillator, Technicalities\n\nHere $A$ and $\\phi$ are arbitrary. Equivalently, one could have\nwritten this as $A\\cos(\\omega_0 t)+B\\sin(\\omega_0 t)$, or as the real\npart of $Ae^{i\\omega_0 t}$. In this last case $A$ could be an\narbitrary complex constant. Thus, there are 2 arbitrary constants\n(either $A$ and $B$ or $A$ and $\\phi$, or the real and imaginary part\nof one complex constant. This is the expectation for a second order\ndifferential equation, and also agrees with the physical expectation\nthat if you know a particle's initial velocity and position you should\nbe able to define its future motion, and that those two arbitrary\nconditions should translate to two arbitrary constants.\n\nA key feature of harmonic motion is that the system repeats itself\nafter a time $T=1/f$, where $f$ is the frequency, and $\\omega=2\\pi f$\nis the angular frequency. The period of the motion is independent of\nthe amplitude. However, this independence is only exact when one can\nneglect higher terms of the potential, $x^3, x^4\\cdots$. Once can\nneglect these terms for sufficiently small amplitudes, and for larger\namplitudes the motion is no longer purely sinusoidal, and even though\nthe motion repeats itself, the time for repeating the motion is no\nlonger independent of the amplitude.\n\nOne can also calculate the velocity and the kinetic energy as a function of time,\n\n$$\n\\begin{eqnarray}\n\\dot{x}&=&-\\omega_0A\\sin(\\omega_0 t-\\phi),\\\\\n\\nonumber\nK&=&\\frac{1}{2}m\\dot{x}^2=\\frac{m\\omega_0^2A^2}{2}\\sin^2(\\omega_0t-\\phi),\\\\\n\\nonumber\n&=&\\frac{k}{2}A^2\\sin^2(\\omega_0t-\\phi).\n\\end{eqnarray}\n$$\n\n## Harmonic Oscillator, Total Energy\n\nThe total energy is then\n\n\n
\n\n$$\n\\begin{equation}\nE=K+V=\\frac{1}{2}m\\dot{x}^2+\\frac{1}{2}kx^2=\\frac{1}{2}kA^2.\n\\label{_auto8} \\tag{9}\n\\end{equation}\n$$\n\nThe total energy then goes as the square of the amplitude.\n\n\nA pendulum is an example of a harmonic oscillator. By expanding the\nkinetic and potential energies for small angles find the frequency for\na pendulum of length $L$ with all the mass $m$ centered at the end by\nwriting the eq.s of motion in the form of a harmonic oscillator.\n\nThe potential energy and kinetic energies are (for $x$ being the displacement)\n\n$$\n\\begin{eqnarray*}\nV&=&mgL(1-\\cos\\theta)\\approx mgL\\frac{x^2}{2L^2},\\\\\nK&=&\\frac{1}{2}mL^2\\dot{\\theta}^2\\approx \\frac{m}{2}\\dot{x}^2.\n\\end{eqnarray*}\n$$\n\nFor small $x$ Newton's 2nd law becomes\n\n$$\nm\\ddot{x}=-\\frac{mg}{L}x,\n$$\n\nand the spring constant would appear to be $k=mg/L$, which makes the\nfrequency equal to $\\omega_0=\\sqrt{g/L}$. Note that the frequency is\nindependent of the mass.\n", "meta": {"hexsha": "8ababaca116b5bd441fbba0fea20fad01372a225", "size": 46330, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/pub/week7/ipynb/.ipynb_checkpoints/week7-checkpoint.ipynb", "max_stars_repo_name": "Shield94/Physics321", "max_stars_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 20, "max_stars_repo_stars_event_min_datetime": "2020-01-09T17:41:16.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T00:48:58.000Z", "max_issues_repo_path": "doc/pub/week7/ipynb/.ipynb_checkpoints/week7-checkpoint.ipynb", "max_issues_repo_name": "Shield94/Physics321", "max_issues_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": 6, "max_issues_repo_issues_event_min_datetime": "2020-01-08T03:47:53.000Z", "max_issues_repo_issues_event_max_datetime": "2020-12-15T15:02:57.000Z", "max_forks_repo_path": "doc/pub/week7/ipynb/.ipynb_checkpoints/week7-checkpoint.ipynb", "max_forks_repo_name": "Shield94/Physics321", "max_forks_repo_head_hexsha": "9875a3bf840b0fa164b865a3cb13073aff9094ca", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 33, "max_forks_repo_forks_event_min_datetime": "2020-01-10T20:40:55.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T20:28:41.000Z", "avg_line_length": 24.9892125135, "max_line_length": 253, "alphanum_fraction": 0.5173105979, "converted": true, "num_tokens": 8454, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4263215925474903, "lm_q2_score": 0.25683199707586785, "lm_q1q2_score": 0.10949302601053636}}
{"text": "```python\n%matplotlib inline\n```\n\n\nWord Embeddings: Encoding Lexical Semantics\n===========================================\n\nWord embeddings are dense vectors of real numbers, one per word in your\nvocabulary. In NLP, it is almost always the case that your features are\nwords! But how should you represent a word in a computer? You could\nstore its ascii character representation, but that only tells you what\nthe word *is*, it doesn't say much about what it *means* (you might be\nable to derive its part of speech from its affixes, or properties from\nits capitalization, but not much). Even more, in what sense could you\ncombine these representations? We often want dense outputs from our\nneural networks, where the inputs are $|V|$ dimensional, where\n$V$ is our vocabulary, but often the outputs are only a few\ndimensional (if we are only predicting a handful of labels, for\ninstance). How do we get from a massive dimensional space to a smaller\ndimensional space?\n\nHow about instead of ascii representations, we use a one-hot encoding?\nThat is, we represent the word $w$ by\n\n\\begin{align}\\overbrace{\\left[ 0, 0, \\dots, 1, \\dots, 0, 0 \\right]}^\\text{|V| elements}\\end{align}\n\nwhere the 1 is in a location unique to $w$. Any other word will\nhave a 1 in some other location, and a 0 everywhere else.\n\nThere is an enormous drawback to this representation, besides just how\nhuge it is. It basically treats all words as independent entities with\nno relation to each other. What we really want is some notion of\n*similarity* between words. Why? Let's see an example.\n\nSuppose we are building a language model. Suppose we have seen the\nsentences\n\n* The mathematician ran to the store.\n* The physicist ran to the store.\n* The mathematician solved the open problem.\n\nin our training data. Now suppose we get a new sentence never before\nseen in our training data:\n\n* The physicist solved the open problem.\n\nOur language model might do OK on this sentence, but wouldn't it be much\nbetter if we could use the following two facts:\n\n* We have seen mathematician and physicist in the same role in a sentence. Somehow they\n have a semantic relation.\n* We have seen mathematician in the same role in this new unseen sentence\n as we are now seeing physicist.\n\nand then infer that physicist is actually a good fit in the new unseen\nsentence? This is what we mean by a notion of similarity: we mean\n*semantic similarity*, not simply having similar orthographic\nrepresentations. It is a technique to combat the sparsity of linguistic\ndata, by connecting the dots between what we have seen and what we\nhaven't. This example of course relies on a fundamental linguistic\nassumption: that words appearing in similar contexts are related to each\nother semantically. This is called the `distributional\nhypothesis `__.\n\n\nGetting Dense Word Embeddings\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nHow can we solve this problem? That is, how could we actually encode\nsemantic similarity in words? Maybe we think up some semantic\nattributes. For example, we see that both mathematicians and physicists\ncan run, so maybe we give these words a high score for the \"is able to\nrun\" semantic attribute. Think of some other attributes, and imagine\nwhat you might score some common words on those attributes.\n\nIf each attribute is a dimension, then we might give each word a vector,\nlike this:\n\n\\begin{align}q_\\text{mathematician} = \\left[ \\overbrace{2.3}^\\text{can run},\n \\overbrace{9.4}^\\text{likes coffee}, \\overbrace{-5.5}^\\text{majored in Physics}, \\dots \\right]\\end{align}\n\n\\begin{align}q_\\text{physicist} = \\left[ \\overbrace{2.5}^\\text{can run},\n \\overbrace{9.1}^\\text{likes coffee}, \\overbrace{6.4}^\\text{majored in Physics}, \\dots \\right]\\end{align}\n\nThen we can get a measure of similarity between these words by doing:\n\n\\begin{align}\\text{Similarity}(\\text{physicist}, \\text{mathematician}) = q_\\text{physicist} \\cdot q_\\text{mathematician}\\end{align}\n\nAlthough it is more common to normalize by the lengths:\n\n\\begin{align}\\text{Similarity}(\\text{physicist}, \\text{mathematician}) = \\frac{q_\\text{physicist} \\cdot q_\\text{mathematician}}\n {\\| q_\\text{\\physicist} \\| \\| q_\\text{mathematician} \\|} = \\cos (\\phi)\\end{align}\n\nWhere $\\phi$ is the angle between the two vectors. That way,\nextremely similar words (words whose embeddings point in the same\ndirection) will have similarity 1. Extremely dissimilar words should\nhave similarity -1.\n\n\nYou can think of the sparse one-hot vectors from the beginning of this\nsection as a special case of these new vectors we have defined, where\neach word basically has similarity 0, and we gave each word some unique\nsemantic attribute. These new vectors are *dense*, which is to say their\nentries are (typically) non-zero.\n\nBut these new vectors are a big pain: you could think of thousands of\ndifferent semantic attributes that might be relevant to determining\nsimilarity, and how on earth would you set the values of the different\nattributes? Central to the idea of deep learning is that the neural\nnetwork learns representations of the features, rather than requiring\nthe programmer to design them herself. So why not just let the word\nembeddings be parameters in our model, and then be updated during\ntraining? This is exactly what we will do. We will have some *latent\nsemantic attributes* that the network can, in principle, learn. Note\nthat the word embeddings will probably not be interpretable. That is,\nalthough with our hand-crafted vectors above we can see that\nmathematicians and physicists are similar in that they both like coffee,\nif we allow a neural network to learn the embeddings and see that both\nmathematicians and physicists have a large value in the second\ndimension, it is not clear what that means. They are similar in some\nlatent semantic dimension, but this probably has no interpretation to\nus.\n\n\nIn summary, **word embeddings are a representation of the *semantics* of\na word, efficiently encoding semantic information that might be relevant\nto the task at hand**. You can embed other things too: part of speech\ntags, parse trees, anything! The idea of feature embeddings is central\nto the field.\n\n\nWord Embeddings in Pytorch\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nBefore we get to a worked example and an exercise, a few quick notes\nabout how to use embeddings in Pytorch and in deep learning programming\nin general. Similar to how we defined a unique index for each word when\nmaking one-hot vectors, we also need to define an index for each word\nwhen using embeddings. These will be keys into a lookup table. That is,\nembeddings are stored as a $|V| \\times D$ matrix, where $D$\nis the dimensionality of the embeddings, such that the word assigned\nindex $i$ has its embedding stored in the $i$'th row of the\nmatrix. In all of my code, the mapping from words to indices is a\ndictionary named word\\_to\\_ix.\n\nThe module that allows you to use embeddings is torch.nn.Embedding,\nwhich takes two arguments: the vocabulary size, and the dimensionality\nof the embeddings.\n\nTo index into this table, you must use torch.LongTensor (since the\nindices are integers, not floats).\n\n\n\n\n\n```python\n# Author: Robert Guthrie\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\nimport config\n\ntorch.manual_seed(1)\n```\n\n\n\n\n \n\n\n\n\n```python\nword_to_ix = {\"hello\": 0, \"world\": 1}\nembeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings\nlookup_tensor = torch.tensor([word_to_ix[\"hello\"]], dtype=torch.long)\nhello_embed = embeds(lookup_tensor)\nprint(hello_embed)\n```\n\n tensor([[-0.8923, -0.0583, -0.1955, -0.9656, 0.4224]], grad_fn=)\n\n\nAn Example: N-Gram Language Modeling\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nRecall that in an n-gram language model, given a sequence of words\n$w$, we want to compute\n\n\\begin{align}P(w_i | w_{i-1}, w_{i-2}, \\dots, w_{i-n+1} )\\end{align}\n\nWhere $w_i$ is the ith word of the sequence.\n\nIn this example, we will compute the loss function on some training\nexamples and update the parameters with backpropagation.\n\n\n\n\n\n```python\nCONTEXT_SIZE = 2\nEMBEDDING_DIM = 10\n# We will use Shakespeare Sonnet 2\ntest_sentence = \"\"\"When forty winters shall besiege thy brow,\nAnd dig deep trenches in thy beauty's field,\nThy youth's proud livery so gazed on now,\nWill be a totter'd weed of small worth held:\nThen being asked, where all thy beauty lies,\nWhere all the treasure of thy lusty days;\nTo say, within thine own deep sunken eyes,\nWere an all-eating shame, and thriftless praise.\nHow much more praise deserv'd thy beauty's use,\nIf thou couldst answer 'This fair child of mine\nShall sum my count, and make my old excuse,'\nProving his beauty by succession thine!\nThis were to be new made when thou art old,\nAnd see thy blood warm when thou feel'st it cold.\"\"\".split()\n# we should tokenize the input, but we will ignore that for now\n# build a list of tuples. Each tuple is ([ word_i-2, word_i-1 ], target word)\ntrigrams = [([test_sentence[i], test_sentence[i + 1]], test_sentence[i + 2])\n for i in range(len(test_sentence) - 2)]\n# print the first 3, just so you can see what they look like\nprint(trigrams[:3])\n\nvocab = set(test_sentence)\nword_to_ix = {word: i for i, word in enumerate(vocab)}\n\nprint(vocab)\nprint(word_to_ix)\n```\n\n [(['When', 'forty'], 'winters'), (['forty', 'winters'], 'shall'), (['winters', 'shall'], 'besiege')]\n {'say,', 'cold.', 'make', 'Were', 'asked,', 'of', 'see', \"deserv'd\", 'Shall', 'small', 'thriftless', 'winters', 'to', 'old,', 'deep', 'praise.', 'all-eating', 'made', 'This', 'the', 'lusty', 'praise', 'where', 'Proving', 'his', 'lies,', 'in', 'mine', 'thine', 'brow,', 'held:', 'now,', 'If', 'it', 'sunken', 'own', 'sum', 'a', 'fair', \"feel'st\", 'weed', 'count,', 'child', 'besiege', 'my', 'thy', 'And', 'couldst', 'on', 'Where', 'thine!', \"excuse,'\", 'more', 'new', \"youth's\", 'forty', 'dig', 'trenches', 'and', 'Then', 'When', \"beauty's\", 'so', 'answer', 'thou', 'old', 'much', 'livery', 'when', 'How', 'by', 'Will', 'Thy', 'days;', 'proud', \"totter'd\", 'shall', 'were', 'being', 'an', 'all', 'To', 'warm', 'be', 'blood', 'field,', \"'This\", 'treasure', 'succession', 'worth', 'shame,', 'use,', 'art', 'beauty', 'gazed', 'within', 'eyes,'}\n {'say,': 0, 'cold.': 1, 'make': 2, 'Were': 3, 'asked,': 4, 'of': 5, 'see': 6, \"deserv'd\": 7, 'Shall': 8, 'small': 9, 'thriftless': 10, 'winters': 11, 'to': 12, 'old,': 13, 'deep': 14, 'praise.': 15, 'all-eating': 16, 'made': 17, 'This': 18, 'the': 19, 'lusty': 20, 'praise': 21, 'where': 22, 'Proving': 23, 'his': 24, 'lies,': 25, 'in': 26, 'mine': 27, 'thine': 28, 'brow,': 29, 'held:': 30, 'now,': 31, 'If': 32, 'it': 33, 'sunken': 34, 'own': 35, 'sum': 36, 'a': 37, 'fair': 38, \"feel'st\": 39, 'weed': 40, 'count,': 41, 'child': 42, 'besiege': 43, 'my': 44, 'thy': 45, 'And': 46, 'couldst': 47, 'on': 48, 'Where': 49, 'thine!': 50, \"excuse,'\": 51, 'more': 52, 'new': 53, \"youth's\": 54, 'forty': 55, 'dig': 56, 'trenches': 57, 'and': 58, 'Then': 59, 'When': 60, \"beauty's\": 61, 'so': 62, 'answer': 63, 'thou': 64, 'old': 65, 'much': 66, 'livery': 67, 'when': 68, 'How': 69, 'by': 70, 'Will': 71, 'Thy': 72, 'days;': 73, 'proud': 74, \"totter'd\": 75, 'shall': 76, 'were': 77, 'being': 78, 'an': 79, 'all': 80, 'To': 81, 'warm': 82, 'be': 83, 'blood': 84, 'field,': 85, \"'This\": 86, 'treasure': 87, 'succession': 88, 'worth': 89, 'shame,': 90, 'use,': 91, 'art': 92, 'beauty': 93, 'gazed': 94, 'within': 95, 'eyes,': 96}\n\n\n\n```python\nclass NGramLanguageModeler(nn.Module):\n\n def __init__(self, vocab_size, embedding_dim, context_size):\n super(NGramLanguageModeler, self).__init__()\n self.embeddings = nn.Embedding(vocab_size, embedding_dim)\n self.linear1 = nn.Linear(context_size * embedding_dim, 128)\n self.linear2 = nn.Linear(128, vocab_size)\n\n def forward(self, inputs):\n embeds = self.embeddings(inputs).view((1, -1))\n out = F.relu(self.linear1(embeds))\n out = self.linear2(out)\n log_probs = F.log_softmax(out, dim=1)\n return log_probs\n\n\nlosses = []\nloss_function = nn.NLLLoss()\nmodel = NGramLanguageModeler(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE)\noptimizer = optim.SGD(model.parameters(), lr=0.001)\n\n\n```\n\n\n```python\nfor epoch in range(10):\n total_loss = 0\n for context, target in trigrams:\n\n # Step 1. Prepare the inputs to be passed to the model (i.e, turn the words\n # into integer indices and wrap them in tensors)\n context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\n\n # Step 2. Recall that torch *accumulates* gradients. Before passing in a\n # new instance, you need to zero out the gradients from the old\n # instance\n model.zero_grad()\n\n # Step 3. Run the forward pass, getting log probabilities over next\n # words\n log_probs = model(context_idxs)\n\n # Step 4. Compute your loss function. (Again, Torch wants the target\n # word wrapped in a tensor)\n loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))\n\n # Step 5. Do the backward pass and update the gradient\n loss.backward()\n optimizer.step()\n\n # Get the Python number from a 1-element Tensor by calling tensor.item()\n total_loss += loss.item()\n losses.append(total_loss)\nprint(losses) # The loss decreased every iteration over the training data!\n```\n\n [521.9658379554749, 519.4242827892303, 516.8998155593872, 514.3911921977997, 511.89916229248047, 509.42258977890015, 506.96097111701965, 504.5128610134125, 502.07800102233887, 499.65542340278625]\n\n\nExercise: Computing Word Embeddings: Continuous Bag-of-Words\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe Continuous Bag-of-Words model (CBOW) is frequently used in NLP deep\nlearning. It is a model that tries to predict words given the context of\na few words before and a few words after the target word. This is\ndistinct from language modeling, since CBOW is not sequential and does\nnot have to be probabilistic. Typcially, CBOW is used to quickly train\nword embeddings, and these embeddings are used to initialize the\nembeddings of some more complicated model. Usually, this is referred to\nas *pretraining embeddings*. It almost always helps performance a couple\nof percent.\n\nThe CBOW model is as follows. Given a target word $w_i$ and an\n$N$ context window on each side, $w_{i-1}, \\dots, w_{i-N}$\nand $w_{i+1}, \\dots, w_{i+N}$, referring to all context words\ncollectively as $C$, CBOW tries to minimize\n\n\\begin{align}-\\log p(w_i | C) = -\\log \\text{Softmax}(A(\\sum_{w \\in C} q_w) + b)\\end{align}\n\nwhere $q_w$ is the embedding for word $w$.\n\nImplement this model in Pytorch by filling in the class below. Some\ntips:\n\n* Think about which parameters you need to define.\n* Make sure you know what shape each operation expects. Use .view() if you need to\n reshape.\n\n\n\n\n\n```python\nCONTEXT_SIZE = 2 # 2 words to the left, 2 to the right\nraw_text = \"\"\"We are about to study the idea of a computational process.\nComputational processes are abstract beings that inhabit computers.\nAs they evolve, processes manipulate other abstract things called data.\nThe evolution of a process is directed by a pattern of rules\ncalled a program. People create programs to direct processes. In effect,\nwe conjure the spirits of the computer with our spells.\"\"\".split()\n\n# By deriving a set from `raw_text`, we deduplicate the array\nvocab = set(raw_text)\nvocab_size = len(vocab)\n\nword_to_ix = {word: i for i, word in enumerate(vocab)}\ndata = []\nfor i in range(2, len(raw_text) - 2):\n context = [raw_text[i - 2], raw_text[i - 1],\n raw_text[i + 1], raw_text[i + 2]]\n target = raw_text[i]\n data.append((context, target))\nprint(data[:5])\n\nprint(word_to_ix)\n```\n\n [(['We', 'are', 'to', 'study'], 'about'), (['are', 'about', 'study', 'the'], 'to'), (['about', 'to', 'the', 'idea'], 'study'), (['to', 'study', 'idea', 'of'], 'the'), (['study', 'the', 'of', 'a'], 'idea')]\n {'computer': 0, 'evolution': 1, 'about': 2, 'they': 3, 'are': 4, 'called': 5, 'People': 6, 'idea': 7, 'computers.': 8, 'pattern': 9, 'of': 10, 'beings': 11, 'spirits': 12, 'other': 13, 'program.': 14, 'we': 15, 'a': 16, 'that': 17, 'to': 18, 'Computational': 19, 'directed': 20, 'our': 21, 'As': 22, 'effect,': 23, 'direct': 24, 'conjure': 25, 'manipulate': 26, 'In': 27, 'spells.': 28, 'inhabit': 29, 'computational': 30, 'abstract': 31, 'study': 32, 'things': 33, 'processes': 34, 'The': 35, 'rules': 36, 'with': 37, 'process.': 38, 'data.': 39, 'evolve,': 40, 'the': 41, 'We': 42, 'create': 43, 'processes.': 44, 'programs': 45, 'process': 46, 'by': 47, 'is': 48}\n\n\n\n```python\ndef make_context_vector(context, word_to_ix):\n idxs = [word_to_ix[w] for w in context]\n return torch.tensor(idxs, dtype=torch.long)\n\n\nmake_context_vector(data[0][0], word_to_ix) # example\n```\n\n\n\n\n tensor([42, 4, 18, 32])\n\n\n\n\n```python\nclass CBOW(nn.Module):\n\n def __init__(self, vocab_size, embedding_dim, context_size):\n super(CBOW, self).__init__()\n self.embeddings = nn.Embedding(vocab_size, embedding_dim)\n self.linear1 = nn.Linear(context_size * embedding_dim, 128)\n self.linear2 = nn.Linear(128, vocab_size)\n \n self.to(config.HOST_DEVICE)\n\n def forward(self, inputs):\n inputs = inputs.to(config.HOST_DEVICE)\n embeds = self.embeddings(inputs).view((1, -1))\n out = F.relu(self.linear1(embeds))\n out = self.linear2(out)\n log_probs = F.log_softmax(out, dim=1)\n return log_probs\n\n# create your model and train. here are some functions to help you make\n# the data ready for use by your module\n\nlosses = []\nloss_function = nn.NLLLoss()\nmodel = CBOW(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE *2)\noptimizer = optim.SGD(model.parameters(), lr=0.001)\n\n\n```\n\n\n```python\nfor epoch in range(100):\n total_loss = 0\n for context, target in data:\n\n context_idxs = torch.tensor(make_context_vector(context, word_to_ix), dtype=torch.long)\n\n model.zero_grad()\n log_probs = model(context_idxs)\n loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long).to(config.HOST_DEVICE))\n\n # Step 5. Do the backward pass and update the gradient\n loss.backward()\n optimizer.step()\n\n # Get the Python number from a 1-element Tensor by calling tensor.item()\n total_loss += loss.item()\n losses.append(total_loss)\nprint(losses) # The loss decreased every iteration over the training data!\n```\n\n [227.96513605117798, 226.33953070640564, 224.7250897884369, 223.12321376800537, 221.5327503681183, 219.95335602760315, 218.38373279571533, 216.82241106033325, 215.27163434028625, 213.73100638389587, 212.1968069076538, 210.6700885295868, 209.1500744819641, 207.6340024471283, 206.12175297737122, 204.61291980743408, 203.10775470733643, 201.60511016845703, 200.10666966438293, 198.61163640022278, 197.1199231147766, 195.63121843338013, 194.14271926879883, 192.65562915802002, 191.16730761528015, 189.68121099472046, 188.1959400177002, 186.71414136886597, 185.23253798484802, 183.75069332122803, 182.26797318458557, 180.7839744091034, 179.30089831352234, 177.81779623031616, 176.33366703987122, 174.85206604003906, 173.36930131912231, 171.88582372665405, 170.40109252929688, 168.91687297821045, 167.43051958084106, 165.9450876712799, 164.45748043060303, 162.96973729133606, 161.48047637939453, 159.991441488266, 158.50047850608826, 157.010014295578, 155.51938772201538, 154.0270857810974, 152.53851675987244, 151.04881501197815, 149.55951476097107, 148.0729103088379, 146.58622431755066, 145.09854412078857, 143.61334228515625, 142.12981605529785, 140.64747190475464, 139.1655023097992, 137.6874279975891, 136.2080373764038, 134.7309467792511, 133.25460290908813, 131.78092551231384, 130.30930876731873, 128.8403356075287, 127.37420415878296, 125.90907168388367, 124.44745779037476, 122.98964381217957, 121.52959251403809, 120.07670259475708, 118.62520599365234, 117.17907500267029, 115.73558521270752, 114.2972764968872, 112.86128568649292, 111.43117451667786, 110.0034122467041, 108.58165979385376, 107.16655611991882, 105.75730538368225, 104.35439801216125, 102.95808625221252, 101.56578516960144, 100.1802282333374, 98.80347967147827, 97.43173885345459, 96.06761407852173, 94.71109199523926, 93.36294507980347, 92.02087163925171, 90.68952512741089, 89.36666655540466, 88.05137276649475, 86.74717879295349, 85.45002460479736, 84.16323351860046, 82.88799285888672, 81.62128496170044, 80.36572122573853, 79.12079429626465, 77.88800954818726, 76.66643762588501, 75.45351839065552, 74.25549387931824, 73.06729936599731, 71.88959503173828, 70.72631669044495]\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "a02580220d602c2b749e0e176fb506985f8c5977", "size": 26694, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "dl4nlp/word_embedding/word_embeddings_tutorial.ipynb", "max_stars_repo_name": "rdcsung/practical-pytorch", "max_stars_repo_head_hexsha": "6c57013c16eb928232af5e9bbe886a41c4ac9f9e", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dl4nlp/word_embedding/word_embeddings_tutorial.ipynb", "max_issues_repo_name": "rdcsung/practical-pytorch", "max_issues_repo_head_hexsha": "6c57013c16eb928232af5e9bbe886a41c4ac9f9e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dl4nlp/word_embedding/word_embeddings_tutorial.ipynb", "max_forks_repo_name": "rdcsung/practical-pytorch", "max_forks_repo_head_hexsha": "6c57013c16eb928232af5e9bbe886a41c4ac9f9e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 47.9245960503, "max_line_length": 2163, "alphanum_fraction": 0.6056791788, "converted": true, "num_tokens": 6293, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014736319616964, "lm_q2_score": 0.2538610126142736, "lm_q1q2_score": 0.10919764519433933}}
{"text": "# SNLP Assignment 1\n\nName 1: Sangeet Sagar\n\n\n\nIn the code above, we create the PyMC variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC's *stochastic variables*, so-called because they are treated by the back end as random number generators. We can demonstrate this fact by calling their built-in `random()` methods.\n\n\n```python\nprint(\"Random output:\", tau.random(), tau.random(), tau.random())\n```\n\n ('Random output:', array(37), array(16), array(36))\n\n\n\n```python\ntest = np.zeros(10)\nprint(test)\ntest[:3] = 3\ntest[3:] = -9\nprint(test)\n```\n\n [ 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n [ 3. 3. 3. -9. -9. -9. -9. -9. -9. -9.]\n\n\n\n```python\n@pm.deterministic\ndef lambda_(tau=tau, lambda_1=lambda_1, lambda_2=lambda_2):\n out = np.zeros(n_count_data)\n out[:tau] = lambda_1 # lambda before tau is lambda1\n out[tau:] = lambda_2 # lambda after (and including) tau is lambda2\n return out\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. Note that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n`@pm.deterministic` is a decorator that tells PyMC this is a deterministic function. That is, if the arguments were deterministic (which they are not), the output would be deterministic as well. Deterministic functions will be covered in Chapter 2. \n\n\n```python\nobservation = pm.Poisson(\"obs\", lambda_, value=count_data, observed=True)\n\nmodel = pm.Model([observation, lambda_1, lambda_2, tau])\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `value` keyword. We also set `observed = True` to tell PyMC that this should stay fixed in our analysis. Finally, PyMC wants us to collect all the variables of interest and create a `Model` instance out of them. This makes our life easier when we retrieve the results.\n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```python\n# Mysterious code to be explained in Chapter 3.\nmcmc = pm.MCMC(model)\nmcmc.sample(40000, 10000, 1)\n```\n\n [-----------------100%-----------------] 40000 of 40000 complete in 12.9 sec\n\n\n```python\nlambda_1_samples = mcmc.trace('lambda_1')[:]\nlambda_2_samples = mcmc.trace('lambda_2')[:]\ntau_samples = mcmc.trace('tau')[:]\n```\n\n\n```python\nfigsize(12.5, 10)\n# histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data) - 20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n### Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```python\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```python\nprint(lambda_1_samples.mean())\nprint(lambda_2_samples.mean())\n```\n\n 17.7672607564\n 22.7047356746\n\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```python\nprint(lambda_1_samples.mean()/lambda_2_samples.mean())\nprint(lambda_1_samples/lambda_2_samples).mean()\n```\n\n 0.78253545917\n 0.783728743238\n\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC part. Just consider all instances where `tau_samples < 45`.)\n\n\n```python\ny = np.bincount(tau_samples)\nprint(y)\nii = np.nonzero(y)[0]\nzip(ii,y[ii]) \n```\n\n [ 0 0 0 0 0 0 0 0 0 0 0 0\n 0 0 0 0 0 0 0 0 0 0 0 0\n 0 0 0 0 0 0 0 0 0 0 0 0\n 0 0 0 4 6 29 1089 3470 10991 14408 3]\n\n\n\n\n\n [(39, 4),\n (40, 6),\n (41, 29),\n (42, 1089),\n (43, 3470),\n (44, 10991),\n (45, 14408),\n (46, 3)]\n\n\n\n\n```python\nix = tau_samples < 45\n\nprint(ix)\nprint(ix.sum())\nprint(len(ix))\n```\n\n [ True True True ..., True True True]\n 15589\n 30000\n\n\n\n```python\nlambda_1_samples[ix].mean()\n```\n\n\n\n\n 17.763521264856525\n\n\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/31/n_is_never_larg/).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Patil, A., D. Huard and C.J. Fonnesbeck. 2010. \nPyMC: Bayesian Stochastic Modelling in Python. Journal of Statistical \nSoftware, 35(4), pp. 1-81. \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```python\nfrom IPython.core.display import HTML\n\n\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "2362e95280d3e6c44e1b23686240376f79af2b8e", "size": 315904, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_stars_repo_name": "CanCeylan/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "11cf66434ed562939feb14888c59b639c878e5e1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-15T15:49:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-15T15:49:31.000Z", "max_issues_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_issues_repo_name": "CanCeylan/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "11cf66434ed562939feb14888c59b639c878e5e1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Ch1_Introduction_PyMC2.ipynb", "max_forks_repo_name": "CanCeylan/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "11cf66434ed562939feb14888c59b639c878e5e1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 245.0768037238, "max_line_length": 90178, "alphanum_fraction": 0.8857564323, "converted": true, "num_tokens": 12208, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.38491214448393346, "lm_q2_score": 0.28140560742914383, "lm_q1q2_score": 0.10831643582535568}}
{"text": "# Data Preparation\n\n**DIVE into Deep Learning**\n___\n\n\n```python\n%matplotlib inline\nimport pprint as pp\nimport tensorflow_datasets as tfds\nimport tensorflow.compat.v2 as tf\nfrom matplotlib import pyplot as plt\nimport numpy as np\nfrom IPython import display\nimport matplotlib.pyplot as plt\n# produce vector inline graphics\nfrom matplotlib_inline.backend_inline import set_matplotlib_formats\nset_matplotlib_formats('svg')\n```\n\n## Loading Data\n\n**What is an example in a dataset?**\n\nA neural network learns from many examples collected together as a *dataset*. For instance, the [MNIST (Modified National Institute of Standards and Technology)](https://en.wikipedia.org/wiki/MNIST_database) dataset consists of labeled handwritten digits.$\\def\\abs#1{\\left\\lvert #1 \\right\\rvert}\n\\def\\Set#1{\\left\\{ #1 \\right\\}}\n\\def\\mc#1{\\mathcal{#1}}\n\\def\\M#1{\\boldsymbol{#1}}\n\\def\\R#1{\\mathsf{#1}}\n\\def\\RM#1{\\boldsymbol{\\mathsf{#1}}}\n\\def\\op#1{\\operatorname{#1}}\n\\def\\E{\\op{E}}\n\\def\\d{\\mathrm{\\mathstrut d}}\n$\n\n,\n 'train': }\n```\nwith a new first dimension of unknown size `None`. Why?\n\n*Hint:* Is the total number of examples divisible by the batch sizs?\n\nYOUR ANSWER HERE\n\n## Release Memory\n\nYou cannot run a notebook if you have insufficient memory. It is important to shut down a notebook to release the memory: \n- `Kernel`->`Shut Down Kernel`.\n\nThe JupyterLab interface also contains tools to help you monitor your memory consumption.\n", "meta": {"hexsha": "6608f83d7d590ea3694c2dd01e08043ad7c816ec", "size": 29514, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "part2/preparation.ipynb", "max_stars_repo_name": "ccha23/divedeep", "max_stars_repo_head_hexsha": "dd9c5e0a589613fa37c467b7863e58c5d22d8d3f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-06-29T00:46:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-29T00:46:39.000Z", "max_issues_repo_path": "part2/preparation.ipynb", "max_issues_repo_name": "ccha23/divedeep", "max_issues_repo_head_hexsha": "dd9c5e0a589613fa37c467b7863e58c5d22d8d3f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "part2/preparation.ipynb", "max_forks_repo_name": "ccha23/divedeep", "max_forks_repo_head_hexsha": "dd9c5e0a589613fa37c467b7863e58c5d22d8d3f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-07-03T02:44:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-03T02:44:06.000Z", "avg_line_length": 25.6643478261, "max_line_length": 310, "alphanum_fraction": 0.5443857153, "converted": true, "num_tokens": 3045, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48047867804790706, "lm_q2_score": 0.2254166210386804, "lm_q1q2_score": 0.10830788008669119}}
{"text": "```julia\nHTML(\"\"\"\n\n\"\"\")\n```\n\n\n\n\n\n\n\n\n\n## 1.1 为什么需要量子计算\n\n### 后摩尔时代\n\n我们对算力的需求在不断增长，但是摩尔定律却不再有效了。\n\n#### 摩尔定律\n\n\n\n
\n\n- 新的思路（三维堆叠，etc）\n- 定制芯片（GPU，TPU，FPGA，etc）\n- 更换计算模型（量子计算，etc）\n\n### 量子多体物理的维度诅咒\n\n**量子多体物理**是指多个具有量子效应的物理对象所构成的系统。这种系统所构成的状态空间往往随着它的粒子数目的增长而指数增长。而量子多体物理的理论研究，将直接对新型材料，新型药物的研究造成影响。\n\n\n\n
\n\n而由于指数增长的空间大小，经典计算机难以精确模拟复杂的多体系统，而需要进行一些假设，简化等，常见的方法包括但不限于：\n\n- DFT，密度泛函\n\n- DMRG，密度矩阵重整化，张量网络\n\n- QMC，量子蒙特卡洛，变分量子蒙特卡洛\n\n其中的很多方法对于计算资源的消耗是巨大的。例如[PEPS++](https://arxiv.org/abs/1806.03761)这个工作甚至用上了中国最强的超级计算机神威太湖之光整机。\n\n所以有人就想：**能不能用量子系统模拟量子系统呢？**\n\n这个人就是：费恩曼（Feynman）[Simulating Physics with Computers](https://people.eecs.berkeley.edu/~christos/classics/Feynman.pdf)\n\n\n\n当然后来在这个想法上有很多工作，用一个可以精确操纵的量子系统模拟另外一个量子系统也称为量子模拟（Quantum Simulation）。这也是被认为一个在近期最有可能成为量子计算机的杀手级应用的方向。\n\n### 作为基础学科的启发性研究\n\n#### 启发经典算法设计\n\n- [Quantum Inspired Recommendation System](https://arxiv.org/abs/1807.04271)\n- [Quantum Inspired PCA](https://arxiv.org/abs/1811.00414)\n- [Simulated Quantum Annealing Can Be Exponentially Faster than Classical Simulated Annealing](https://arxiv.org/abs/1601.03030)\n\n#### 帮助我们获得精确控制量子系统的能力\n\n- 控制单量子比特系统\n- 控制多量子比特系统\n- etc...\n\n#### 帮助我们理解这个世界\n\n- 量子机器学习\n- 宇宙学：[Quantum Circuit Cosmology: The Expansion of the Universe Since the First Qubit](https://arxiv.org/abs/1702.06959)\n- 黑洞：[Quantum Circuit Model of Black Hole Evaporation](https://arxiv.org/abs/1807.07672)\n- etc.\n\n### 阅读材料（可能需要VPN）\n\n- [Why we need quantum computing](https://www.research.ibm.com/ibm-q/learn/what-is-quantum-computing/#)\n- [Julia语言入门](https://www.bilibili.com/video/av28178443/)\n\n\n### 课程将用到的材料\n\n- Michael A. Nielsen & Isaac L. Chuang, Quantum Computation & Quantum Information\n- Yao.jl - Extensible Efficient Quantum Algorithm Design for Humans\n\n## 1.2 经典的逻辑电路\n\n经典的逻辑电路构成了我们现代计算机的基础，本章我们将着重学习一些经典逻辑电路的基础知识，然后之后我将介绍如何从经典的逻辑电路过度到量子线路。\n\n### 逻辑比特\n\n一般情况下我们往往使用比特，也就是两种不同的物理状态来进行计算，我们将其称为**比特**。而理论上，我们将这两种状态抽象出来，用数学符号表示之，从而简化问题。我们将这样的抽象称为**逻辑比特**，一个理论的逻辑比特，在实际的物理实现上有可能对应多个**物理比特**。\n\n我们可以使用我们的**Yao**来定义一组逻辑比特\n\n\n```julia\nusing Yao\n\nArrayReg(bit\"000\")\n```\n\n ┌ Info: Recompiling stale cache file /Users/roger/.julia/compiled/v1.1/Yao/TDiQQ.ji for Yao [5872b779-8223-5990-8dd0-5abbb0748c8c]\n └ @ Base loading.jl:1184\n\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 3/3\n\n\n\n逻辑比特的向量表示，实际上我们也可以用一个one hot向量表示逻辑比特，例如逻辑比特01，可以表示为\n\n\n| 向量的元素值 | 对应的逻辑比特 |\n| ---------- | ------------ |\n| 0 | 00 |\n| 1 | 01 |\n| 0 | 10 |\n| 0 | 11 |\n\n### 逻辑门\n\n逻辑门是操作逻辑比特的一种特殊函数，它的输入是二进制的比特，输出是另外一组二进制的比特。我们常见的操作有逻辑：与，或，非\n\n与：\n\n- 如果两个输入的比特都为0，那么输出0\n- 如果两个输入的比特都为1，那么输出1\n- 如果两个输入的比特不同，那么也输出0\n\n### 布尔代数和真值表\n\n用文字描述上面的操作非常麻烦，数学上我们有布尔代数和真值表来描述逻辑电路。例如非门：\n\n非：\n\n- 如果输入的比特为 0，那么输出1\n- 如果输入的比特为 1，那么输出0\n\n真值表\n\n| $A$ | $\\neg A$ |\n|-----|----------|\n| 0 | 1 |\n| 1 | 0 |\n\n如果我们用一个独热编码（onehot）的向量来表示一个逻辑比特，那么我们可以用线性代数来表示逻辑门的运算，例如我们用如下的方式表示单个比特\n\n$$\n0 = \\begin{pmatrix} 1\\\\ 0 \\end{pmatrix}, \\quad 1 = \\begin{pmatrix} 0 \\\\ 1 \\end{pmatrix}\n$$\n\n我们有\n\n$$\n\\neg 0 = \\begin{pmatrix} 0 & 1\\\\1 & 0 \\end{pmatrix} \\begin{pmatrix} 1\\\\ 0 \\end{pmatrix} = \\begin{pmatrix} 0\\\\ 1\\end{pmatrix} = 1\n$$\n\n同理有\n\n$$\n\\neg 1 = \\begin{pmatrix} 0 & 1\\\\1 & 0 \\end{pmatrix} \\begin{pmatrix} 0\\\\ 1 \\end{pmatrix} = \\begin{pmatrix} 1\\\\ 0\\end{pmatrix}\n$$\n\n我们以后为了简便，将这个矩阵记为 **X**\n\n你可以用Yao来验证上述结论，其中 **X** 即为我们所说的非门\n\n\n```julia\napply!(ArrayReg(bit\"0\"), X) == ArrayReg(bit\"1\")\n```\n\n\n\n\n true\n\n\n\n#### 练习\n\n1. 或门（**OR**）是一个两比特门，它的定义是只要两个比特中有一个比特是 1 那么就输出 1，写出它的真值表和矩阵形式\n2. Toffli门是一个三比特门，它的输入是 **A,B,C**，定义为 **A, B** 为控制比特，当**A，B** 都为1时，翻转 **C**\n\n#### 答案\n\n#### 1. 或门（**OR**）\n\n真值表\n\n| AB | **OR**(A, B) |\n| -- | ------------ |\n| 00 | 0 |\n| 01 | 1 |\n| 10 | 1 |\n| 11 | 1 |\n\n矩阵形式\n\n$$\nOR = \\begin{pmatrix}\n1 & 0 & 0 & 0\\\\\n0 & 1 & 1 & 1\n\\end{pmatrix}\n$$\n\n我们有\n\n$$\n\\begin{pmatrix}1\\\\0\\\\0\\\\0 \\end{pmatrix} \\cdot OR = \\begin{pmatrix}1\\\\0\\end{pmatrix}\\quad\n\\begin{pmatrix}0\\\\1\\\\0\\\\0 \\end{pmatrix} \\cdot OR = \\begin{pmatrix}0\\\\1\\end{pmatrix}\\quad\n\\begin{pmatrix}0\\\\0\\\\1\\\\0 \\end{pmatrix} \\cdot OR = \\begin{pmatrix}0\\\\1\\end{pmatrix}\\quad\n\\begin{pmatrix}0\\\\0\\\\0\\\\1 \\end{pmatrix} \\cdot OR = \\begin{pmatrix}0\\\\1\\end{pmatrix}\n$$\n\n#### 2. Toffli门\n\n真值表\n\n| ABC | 000 | 001 | 010 | 011 | 100 | 101 | 110 | 111 |\n|:-----------:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|:---:|\n| Toffli(ABC) | 000 | 001 | 010 | 011 | 100 | 101 | 111 | 110 |\n\n矩阵\n\n\n```julia\nusing Latexify\n\nlatexarray(Int.(mat(ConstGate.Toffoli)))\n```\n\n\n\n\n\\begin{equation}\n\\left[\n\\begin{array}{cccccccc}\n1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n\\end{array}\n\\right]\n\\end{equation}\n\n\n\n\n### 可逆计算\n\n可逆计算，顾名思义是说计算过程中不会丢失信息，可以从结果反推出初始状态的计算过程。\n\n\n```julia\nInt.(inv(mat(ConstGate.Toffoli)))\n```\n\n\n\n\n 8×8 Array{Int64,2}:\n 1 0 0 0 0 0 0 0\n 0 1 0 0 0 0 0 0\n 0 0 1 0 0 0 0 0\n 0 0 0 0 0 0 0 1\n 0 0 0 0 1 0 0 0\n 0 0 0 0 0 1 0 0\n 0 0 0 0 0 0 1 0\n 0 0 0 1 0 0 0 0\n\n\n\n对一个比特，可逆计算的门有哪些？\n\n两个比特呢？\n\nCNOT（控制翻转）就是一种，因为连续进行两次翻转就会回到原先的状态\n\n\n```julia\nCNOT = control(2, 2, 1=>X)\nInt.(mat(CNOT))\n```\n\n\n\n\n 4×4 Array{Int64,2}:\n 1 0 0 0\n 0 1 0 0\n 0 0 0 1\n 0 0 1 0\n\n\n\n三个比特呢？\n\nToffli门就是三个比特的可逆门，试试看用Toffli连续作用两次会发生什么？\n\n\n```julia\nusing Yao\n\nr = rand_state(3)\nr1 = copy(r) |> ConstGate.Toffoli |> ConstGate.Toffoli\nr1 ≈ r\n```\n\n\n\n\n true\n\n\n\n可逆计算要求，存在对应矩阵的逆矩阵，对于一个门的矩阵形式 $A$，存在 $B$ 使得他们的乘积为1\n\n$$\nA B = I, \\quad \\exists B\n$$\n\n### 从经典到量子\n\n如果我们不限制这些门矩阵只能是实数0或者1，也不限制状态向量是onehot向量呢？\n\n## 1.3 量子线路模型\n\n上一节我们学习了经典线路模型。而量子线路模型可以看作是经典线路模型的推广\n\n### 量子态\n\n量子线路使用量子态表示当前的计算状态，我们将经典线路中对状态为onehot的要求放松一些：\n\n允许**任意复数，模为1的向量作为当前计算的状态表示。**\n\n而它的物理意义即为量子力学中的量子态。很自然的，他们可以这样叠加\n\n\n```julia\nr = ArrayReg(bit\"010\") + ArrayReg(bit\"110\")\n```\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 3/3\n\n\n\n\n```julia\nstate(r)\n```\n\n\n\n\n 8×1 Array{Complex{Float64},2}:\n 0.0 + 0.0im\n 0.0 + 0.0im\n 1.0 + 0.0im\n 0.0 + 0.0im\n 0.0 + 0.0im\n 0.0 + 0.0im\n 1.0 + 0.0im\n 0.0 + 0.0im\n\n\n\n而量子态可以在物理过程上用Unitary矩阵进行演化。\n\n所以我们要求量子线路中的门也都是unitary，回想上一节的结论：**量子计算的是一种可逆计算**，每个量子门的逆就是它的共轭转置（adjoint，dagger）\n\n恰好，我们上一节介绍的几个可逆的门都是unitary矩阵，例如CNOT和Toffli\n\n\n```julia\nisunitary(CNOT)\n```\n\n\n\n\n true\n\n\n\n\n```julia\nisunitary(ConstGate.Toffoli)\n```\n\n\n\n\n true\n\n\n\n## Bloch球\n\n对于一个量子比特，它的向量表示为\n\n$$\n\\begin{pmatrix}\na\\\\\nb\n\\end{pmatrix}\n$$\n\n由于我们要求它的模为1，很自然的，由于 $a^2 + b^2 = 1$ 我们有\n\n$$\na = cos{\\theta} e^{i\\delta}, \\quad b = sin{\\theta} e^{i(\\phi + \\delta)}\n$$\n\n忽略全局global phase （为什么？）就可以得到\n\n$$\n\\Psi = cos{\\theta} |0\\rangle + sin{\\theta} e^{i\\phi} |1\\rangle\n$$\n\n这也就意味着，任何对单比特的操作都可以看成是Bloch球上的旋转。让我们来试几个单比特门\n\n(打开[bloch_sphere.jl](https://github.com/QuantumBFS/SSSS/blob/master/4_quantum/bloch_sphere.jl))\n\n### 1. Pauli门\n\n\n```julia\nmat(X)\n```\n\n\n\n\n 2×2 LuxurySparse.PermMatrix{Complex{Float64},Int64,Array{Complex{Float64},1},Array{Int64,1}}:\n 0 1.0+0.0im\n 1.0+0.0im 0 \n\n\n\nPauli门是常数门，Yao会提前分配常数门的矩阵所需的内存，不需要担心使用常数门进行计算会发生额外的内存分配\n\n\n```julia\n@allocated mat(X)\n```\n\n\n\n\n 0\n\n\n\n而定义一个新的常数门也仅仅只需要一行\n\n\n```julia\n@const_gate MyConstGate = rand(4, 4)\n```\n\n\n```julia\n@allocated mat(MyConstGate)\n```\n\n\n\n\n 0\n\n\n\n\n```julia\nnqubits(MyConstGate)\n```\n\n\n\n\n 2\n\n\n\n### 2. Phase门\n\n### 3. 旋转门\n\n1. Rx\n\n2. Ry\n\n3. Rz\n\n旋转门的矩阵形式是：\n\n$$\ncos{\\frac{\\theta}{2}} \\mathbf{I} - i sin{\\frac{\\theta}{2}} \\mathbf{U}\n$$\n\n\n\n```julia\nmat(Rx(0.1))\n```\n\n\n\n\n 2×2 StaticArrays.SArray{Tuple{2,2},Complex{Float64},2,4}:\n 0.99875+0.0im 0.0-0.0499792im\n 0.0-0.0499792im 0.99875+0.0im \n\n\n\n### 4. Hadmard门\n\n## 2.1 制备一个GHZ态\n\n\n\n在Yao里我们用block来描述量子线路，最基本的门是primitive block，例如我们这里要用到的X门和H门，primitive block是指没有subblock（子block）的block\n\n\n```julia\nusing Yao\nsubblocks(X)\n```\n\n\n\n\n ()\n\n\n\n而我们使用不同的composite block将block组装起来就可以构建出更大的quantum circuit。例如我们可以将H门串起来\n\n\n```julia\nchain(H, H, H, H)\n```\n\n\n\n\n \u001b[36mnqubits: 1, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ H gate\n ├─ H gate\n ├─ H gate\n └─ H gate\n\n\n\n这就构成来一个非常简单的量子线路，它会不断对输入的单比特作用Hadmard门\n\n而有了横向组装门的方法，我们如何在纵向组装呢？你可以用kron，纵向排列的门相当于这些门的张量积。别忘了利用语法糖\n\n\n```julia\nkron(H for _ in 1:4)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[36m\u001b[1mkron\u001b[22m\u001b[39m\n ├─ \u001b[37m\u001b[1m1\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[37m\u001b[1m2\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[37m\u001b[1m3\u001b[22m\u001b[39m=>H gate\n └─ \u001b[37m\u001b[1m4\u001b[22m\u001b[39m=>H gate\n\n\n\n当然你也可以指定位置，但是这个时候就要记得输入比特的数量，因为程序并不能够自己推导出总共的比特数目\n\n\n```julia\nkron(4, 1=>X, 3=>H)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[36m\u001b[1mkron\u001b[22m\u001b[39m\n ├─ \u001b[37m\u001b[1m1\u001b[22m\u001b[39m=>X gate\n └─ \u001b[37m\u001b[1m3\u001b[22m\u001b[39m=>H gate\n\n\n\n但是加入我忘记输入比特数目，或者我暂时还没想好要用多少个比特怎么办？没关系！\n\n\n```julia\nkron(1=>X, 3=>H)\n```\n\n\n\n\n (n -> kron(n, 1 => X gate, 3 => H gate))\n\n\n\nYao在无法推导出比特数目的时候会返回一个以总比特数为输入的匿名函数，你依然可以把它当作正常的block来使用，Yao会在能够推导出比特数目的时候自动把它填进去，例如\n\n\n```julia\nchain(kron(1=>X, 3=>H), kron(H for _ in 1:4))\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ \u001b[36m\u001b[1mkron\u001b[22m\u001b[39m\n │ ├─ \u001b[37m\u001b[1m1\u001b[22m\u001b[39m=>X gate\n │ └─ \u001b[37m\u001b[1m3\u001b[22m\u001b[39m=>H gate\n └─ \u001b[36m\u001b[1mkron\u001b[22m\u001b[39m\n ├─ \u001b[37m\u001b[1m1\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[37m\u001b[1m2\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[37m\u001b[1m3\u001b[22m\u001b[39m=>H gate\n └─ \u001b[37m\u001b[1m4\u001b[22m\u001b[39m=>H gate\n\n\n\n\n但是GHZ里还有控制门，这个要怎么写呢？类似的在Yao里我们使用Julia自带的 `Pair` 类型来指定位置，一个1号比特控制2号比特上X门的控制模块可以这么写\n\n\n```julia\ncontrol(4, 1, 2=>X)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m1\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n └─ \u001b[37m\u001b[1m(2,)\u001b[22m\u001b[39m X gate\n\n\n\n注意，如果你不写总比特数，就会返回一个函数\n\n\n```julia\ncontrol(1, 2=>X)\n```\n\n\n\n\n (n -> control(n, 1, 2 => X gate))\n\n\n\n那么到这里我们就可以构建上面画的这个GHZ的线路了\n\n\n```julia\ncircuit = chain(\n kron(1=>X, (k=>H for k in 2:4)...), # 第一层\n control(2, 1=>X), # 第一个CNOT\n control(4, 3=>X),\n control(3, 1=>X),\n control(4, 3=>X),\n kron(H for _ in 1:4), # 最后一层H\n)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ \u001b[36m\u001b[1mkron\u001b[22m\u001b[39m\n │ ├─ \u001b[37m\u001b[1m1\u001b[22m\u001b[39m=>X gate\n │ ├─ \u001b[37m\u001b[1m2\u001b[22m\u001b[39m=>H gate\n │ ├─ \u001b[37m\u001b[1m3\u001b[22m\u001b[39m=>H gate\n │ └─ \u001b[37m\u001b[1m4\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m2\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m X gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(3,)\u001b[22m\u001b[39m X gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m3\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m X gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(3,)\u001b[22m\u001b[39m X gate\n └─ \u001b[36m\u001b[1mkron\u001b[22m\u001b[39m\n ├─ \u001b[37m\u001b[1m1\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[37m\u001b[1m2\u001b[22m\u001b[39m=>H gate\n ├─ \u001b[37m\u001b[1m3\u001b[22m\u001b[39m=>H gate\n └─ \u001b[37m\u001b[1m4\u001b[22m\u001b[39m=>H gate\n\n\n\n\n注意上面的门的作用顺序和线路图略有不同（线路里两个control是同时作用的），但是是等价的。\n\n接下来让我们来验证一下，这个线路是否能够从000制备出GHZ态\n\n\n```julia\nr = ArrayReg(bit\"0000\") |> circuit\n```\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 4/4\n\n\n\n\n```julia\nusing Plots\n\nresults = measure(r; nshots=2000);\nhistogram(results; nbins=16, legend=nothing, xlabel=\"bit configuration\", xticks=((0:15).+0.5, 0:15))\n```\n\n\n\n\n \n\n \n\n\n\n虽然一般的来说，构建线路只需要 `control`, `chain`, `kron` 三种复合模块就可以了，但是对于数值模拟，但是实际使用上我们还提供了很多不同的复合模块来帮助你快速定义模型，比如上面一排Hadmard的例子，你可以直接使用repeat模块来构造\n\n\n```julia\nrepeat(4, H)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[36m\u001b[1mrepeat on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m2\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m3\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m4\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n └─ H gate\n\n\n\n我们不妨来看看repeat的文档，Yao的大部分函数都可以在help模式中查看文档和用例\n\n\n```julia\n?repeat(4, H)\n```\n\n\n\n\n```\nrepeat(n, x::AbstractBlock[, locs]) -> RepeatedBlock{n}\n```\n\nCreate a [`RepeatedBlock`](@ref) with total number of qubits `n` and the block to repeat on given location or on all the locations.\n\n# Example\n\nThis will create a repeat block which puts 4 X gates on each location.\n\n```jldoctest\njulia> repeat(4, X)\nnqubits: 4, datatype: Complex{Float64}\nrepeat on (1, 2, 3, 4)\n└─ X gate\n```\n\nYou can also specify the location\n\n```jldoctest\njulia> repeat(4, X, (1, 2))\nnqubits: 4, datatype: Complex{Float64}\nrepeat on (1, 2)\n└─ X gate\n```\n\nBut repeat won't copy the gate, thus, if it is a gate with parameter, e.g a `phase(0.1)`, the parameter will change simultaneously.\n\n```jldoctest\njulia> g = repeat(4, phase(0.1))\nnqubits: 4, datatype: Complex{Float64}\nrepeat on (1, 2, 3, 4)\n└─ phase(0.1)\n\njulia> g.content\nphase(0.1)\n\njulia> g.content.theta = 0.2\n0.2\n\njulia> g\nnqubits: 4, datatype: Complex{Float64}\nrepeat on (1, 2, 3, 4)\n└─ phase(0.2)\n```\n\n\n\n\n然后对单个的模块我们还可以直接用put，而不用专门kron\n\n\n```julia\nput(4, 1=>X)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n └─ X gate\n\n\n\nput虽然可以作用任意大小的block，但是它对小的block更高效，对大的block，我们需要稍后会介绍到的concentrator。但是现在我们可以把上面的线路重写为\n\n\n```julia\ncircuit2 = chain(\n 4,\n put(1=>X),\n repeat(H, 2:4),\n control(2, 1=>X),\n control(4, 3=>X),\n control(3, 1=>X),\n control(4, 3=>X),\n repeat(H, 1:4),\n)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ X gate\n ├─ \u001b[36m\u001b[1mrepeat on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m2\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m3\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m4\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ H gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m2\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m X gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(3,)\u001b[22m\u001b[39m X gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m3\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m X gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(3,)\u001b[22m\u001b[39m X gate\n └─ \u001b[36m\u001b[1mrepeat on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m2\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m3\u001b[22m\u001b[39m\u001b[36m\u001b[1m, \u001b[22m\u001b[39m\u001b[36m\u001b[1m4\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n └─ H gate\n\n\n\n\n## 2.2 量子傅立叶变换\n\n量子傅立叶变换可以用下面的线路表示，试试自己用Yao来定义这个线路？\n\n\n\n量子傅立叶变换是很多量子算法的基础模块，它是经典的快速傅立叶变换的量子版本，经典的傅立叶变换可以写成\n\n\n$$\ny_k = \\sum_{j=0}^{N-1} e^{\\frac{2\\pi i k j}{N}} x_j\n$$\n\n而量子傅立叶变换则定义为\n\n$$\n\\sum_j \\alpha_j |j\\rangle \\rightarrow \\sum_k \\hat{\\alpha}_k |k\\rangle, \\quad where \\quad \\hat{\\alpha}_k = \\frac{1}{\\sqrt{N}}\\sum_{j}^{N-1} e^{2\\pi ijk/N}\\alpha_j\n$$\n\n量子傅立叶变换可以用下面的线路表示，试试自己用Yao来定义这个线路？\n\n\n\n它会将一个函数变换到频率空间\n\n\n```julia\nusing FFTW, Interact, Plots\n\nxs = LinRange(-5, 5, 10000)\nl = @layout (1, 2)\n\nf(x) = sin(x^2) * exp(x^2/10)\n\n\n@manipulate for k in 1:0.1:2\n ys = f.(k * xs)\n plot(xs, [ys, abs.(fft(ys))], layout=l, ylims=(-10, 10), size=(1000, 200))\nend\n```\n\n\n\n\n Unable to load WebIO. Please make sure WebIO works for your Jupyter client.\n \n
\n \n\n\n\n\n\n很自然的我们可以用相位偏移来实现这个操作，因为相位偏移（phase shift）门有如下的形式：\n\n$$\n\\begin{pmatrix}\n1 & 0\\\\\n0 & e^{i\\theta}\n\\end{pmatrix}\n$$\n\n而我们上面定义的（量子）傅立叶变换可以写成下面的矩阵形式\n\n$$\n\\begin{pmatrix}\n1 & 1 & 1 & \\dots & 1 \\\\\n1 & \\omega & \\omega^2 & \\dots & \\omega^{N-1} \\\\\n1 & \\omega^2 & \\omega^4 & \\dots & \\omega^{2N-2} \\\\\n\\vdots & \\vdots & \\vdots & \\vdots & \\vdots \\\\\n1 & \\omega^N-1 & \\omega^{2N-2} & \\vdots & \\omega^{(N-1)(N-1)}\n\\end{pmatrix} \\quad \\omega^N = 1, \\quad \\omega = e^{2\\pi i/N}\n$$\n\n我们定义下面的记号，对二进制整数有这样两种记号：\n\n$$\n\\begin{aligned}\n(k)_{(10)} &= \\text{LSB}[k_1 k_2 \\dots k_{n}]_{2} \\\\\n&= k_1 2^{n-1} + k_2 2^{n-2} \\dots k_{n} 2^{0}\\\\\n&= \\sum_{l=1}^{n} k_l 2^{n - l}\n\\end{aligned}\n$$\n\n或者\n\n$$\n\\begin{aligned}\n(k)_{(10)} &= \\text{MSB}[k_1 k_2 \\dots k_n]_{2}\\\\\n&= k_1 2^{0} + k_2 2^{1} \\dots k_{n} 2^{n-1}\\\\\n&= \\sum_{l=1}^{n} k_l 2^{l-1}\n\\end{aligned}\n$$\n\n我们记后者为 MSB (Most Significant Bit numbering) 前者为 LSB (Least Significant Bit numbering)\n\n类似的对二进制小数也有类似的记号：\n\n$$\n\\begin{aligned}\n(0.k)_{(10)} &= \\text{LSB}[k_1 k_2 \\dots k_n]_{(2)} / 2^n\\\\\n&= \\text{MSB} [0.k_1 k_2 \\dots k_n]_{(2)}\\\\\n&= k_1 2^{-1} + k_2 2^{-2} \\cdots k_n 2^{-n}\\\\ \n&= \\sum_{l=1}^{n} k_l 2^{-l} \\\\\n\\end{aligned}\n$$\n\n$$\n\\begin{aligned}\n(0.k)_{(10)} &= \\text{MSB}[k_1 k_2 \\cdots k_n]_{(2)} / 2^n \\\\\n&= \\text{LSB} [0.k_1 k_2 \\dots k_n]_{(2)}\\\\\n&= k_1 2^{-n} + k_2 2^{-(n-1)} \\cdots k_n 2^{-1}\\\\\n&= \\sum_{l=1}^{n} k_l 2^{n-l+1}\n\\end{aligned}\n$$\n\n而一般地，我们可以定义\n\n$$\nLSB[0.k_{j+1} \\cdots k_{j+n}]_{(2)} = \\sum_{l=1}^n k_{j+l} 2^{-(j+l)} = LSB[0.k_1 \\cdots k_{n}]_{(2)} / 2^j\\\\\nMSB[0.k_{j+1} \\cdots k_{j+n}]_{(2)} = \\sum_{l=1}^n k_{j+l} 2^{n-(j+l)+1} = MSB[0.k_1 \\cdots k_{n}]_{(2)} / 2^j\n$$\n\n我们观察到对上面的量子傅立叶变换，不妨假设 $j$ 和 $k$ 都是 $n$ 位二进制数\n\n$$\n\\begin{aligned}\n|x\\rangle &= \\frac{1}{2^{n/2}} \\sum_{k=0}^{2^n-1} e^{2\\pi i \\cdot \\text{LSB}[x_1 x_2\\cdots x_n]_{(2)} k/2^n} |k\\rangle\\\\\n&= \\frac{1}{2^{n/2}} \\sum_{k=0}^{2^n-1} e^{2\\pi i \\cdot \\text{LSB}[0.x_1 x_2 \\cdots x_n]_{(2)} k} |k\\rangle\\\\\n&= \\frac{1}{2^{n/2}} \\sum_{\\{k_1, k_2, \\cdots k_n\\}\\in \\{0, 1\\}^n} e^{2\\pi i \\cdot \\text{LSB}[0.x_1 x_2 \\cdots x_n]_{(2)} \\text{MSB}[k_1 k_2 \\cdots k_n]_{(2)}} |MSB[k_1 k_2 \\cdots k_n]_{(2)} \\rangle \\\\\n\\end{aligned}\n$$\n\n$$\n\\begin{aligned}\n|x\\rangle &= \\frac{1}{2^{n/2}} \\sum_{\\{k_1, k_2, \\cdots k_n\\}\\in \\{0, 1\\}^n} e^{2\\pi i \\cdot \\sum_{l=1}^n k_l 2^{l-1} \\cdot \\text{LSB}[0.x_1 x_2 \\cdots x_n]_{(2)}} |MSB[k_1 k_2 \\cdots k_n]_{(2)} \\rangle \\\\\n&= \\frac{1}{2^{n/2}} \\sum_{\\{k_1, k_2, \\cdots k_n\\}\\in \\{0, 1\\}^n} e^{2\\pi i \\cdot \\sum_{l=1}^n k_{l} \\cdot \\text{LSB}[0.x_{l} x_{l+1} \\cdots x_{n}]_{(2)}} |MSB[k_1 k_2 \\cdots k_n]_{(2)}\\rangle\n\\end{aligned}\n$$\n\n$$\n\\begin{aligned}\n|x\\rangle &= \\frac{1}{2^{n/2}} \\sum_{\\{k_1, k_2, \\cdots k_n\\}\\in \\{0, 1\\}^n} \\bigotimes_{l=1}^n e^{2\\pi i k_{l} \\cdot \\text{LSB}[0.x_{l} x_{l+1} \\cdots x_{n}]_{(2)}} |k_l^{\\text{MSB}}\\rangle\\\\\n&= \\frac{1}{2^{n/2}} \\bigotimes_{l=1}^n \\sum_{k_{l} \\in \\{0, 1\\}} e^{2\\pi i k_{l} \\cdot \\text{LSB}[0.x_{l} x_{l+1} \\cdots x_{n}]_{(2)}} |k_l^{\\text{MSB}}\\rangle\\\\\n&= \\frac{1}{2^{n/2}} \\bigotimes_{l=1}^n [|0^{\\text{MSB}}\\rangle + e^{2\\pi i \\cdot \\text{LSB}[0.x_{l} x_{l+1} \\cdots x_{n}]_{(2)}} |1^{\\text{MSB}}\\rangle ] \\\\\n&= \\frac{1}{2^{n/2}} \\bigotimes_{l=1}^n [|0^{\\text{MSB}}\\rangle + \\omega_{n-l+1}^{\\text{LSB}[x_{l} x_{l+1} \\cdots x_{n}]_{(2)}} |1^{\\text{MSB}}\\rangle ] \\quad where \\quad \\omega_k = e^{2\\pi i / 2^k}\n\\end{aligned}\n$$\n\nYao里默认使用和数组角标顺序一致的MSB，下面我们先从 $|\\text{MSB}[01]\\rangle$ 来看看要怎么做\n\n$$\n\\begin{aligned}\n|\\text{LSB}[10] \\rangle &= \\frac{1}{2} [|0^{MSB}\\rangle + \\omega_2^2 |1^{MSB}\\rangle] \\otimes [|0^{MSB}\\rangle + |1^{MSB}\\rangle] = \\frac{1}{2} ( |0\\rangle - |1\\rangle + |2\\rangle - |3\\rangle )\n\\end{aligned}\n$$\n\n这个结构可以用这样一个H门+控制shift门+H门来实现\n\n\n```julia\nc = chain(2, put(1=>H), control(2, 1=>shift(2π / 1 << 2)), put(2=>H))\n```\n\n\n\n\n \u001b[36mnqubits: 2, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ H gate\n ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m2\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m shift(1.5707963267948966)\n └─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m2\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n └─ H gate\n\n\n\n\n\n```julia\nArrayReg(bit\"01\") |> c |> state\n```\n\n\n\n\n 4×1 Array{Complex{Float64},2}:\n 0.4999999999999999 + 0.0im\n -0.4999999999999999 + 0.0im\n 0.4999999999999999 + 0.0im\n -0.4999999999999999 + 0.0im\n\n\n\n对任意的QFT，我们可以用下面这样递归的方式实现\n\n\n\n\n```julia\nA(i, j) = control(i, j=>shift(2π/(1<<(i-j+1))))\nB(n, i) = chain(n, i==j ? put(i=>H) : A(j, i) for j in i:n)\nqft(n) = chain(B(n, i) for i in 1:n)\n```\n\n\n\n\n qft (generic function with 1 method)\n\n\n\n\n```julia\nqft(4)\n```\n\n\n\n\n \u001b[36mnqubits: 4, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n │ ├─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n │ │ └─ H gate\n │ ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m2\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m shift(1.5707963267948966)\n │ ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m3\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m shift(0.7853981633974483)\n │ └─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(1,)\u001b[22m\u001b[39m shift(0.39269908169872414)\n ├─ \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n │ ├─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m2\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n │ │ └─ H gate\n │ ├─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m3\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ │ └─ \u001b[37m\u001b[1m(2,)\u001b[22m\u001b[39m shift(1.5707963267948966)\n │ └─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(2,)\u001b[22m\u001b[39m shift(0.7853981633974483)\n ├─ \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n │ ├─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m3\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n │ │ └─ H gate\n │ └─ \u001b[31m\u001b[1mcontrol(\u001b[22m\u001b[39m\u001b[31m\u001b[1m4\u001b[22m\u001b[39m\u001b[31m\u001b[1m)\u001b[22m\u001b[39m\n │ └─ \u001b[37m\u001b[1m(3,)\u001b[22m\u001b[39m shift(1.5707963267948966)\n └─ \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n └─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m4\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n └─ H gate\n\n\n\n\n### FFT和QFT的关系\n\n通过上面的推导我们发现实际上QFT相当于颠倒了bit numbering的离散FFT（DFT），而我们从上面的线路图里可以很容易数出来，QFT的复杂度是 $O(n^2)$ 量级的。而对于n个比特，离散傅立叶变换需要 $n 2^n$ 的复杂度。但是实际上由于目前并没有真正的量子硬件使用我们在经典模拟的时候可以用DFT来进行模拟。Yao的可扩展性提供了很方便的接口来做到这一点。\n\n我们首先定义一个 `AbstractBlock` 的子类型\n\n\n```julia\nstruct QFT{N, T} <: PrimitiveBlock{N, T} end\n\nQFT(::Type{T}, n::Int) where T = QFT{n, T}()\nQFT(n::Int) = QFT(ComplexF64, n)\n```\n\n\n\n\n QFT\n\n\n\n然后让我们定义它的矩阵形式，而实际上这个时候 `QFT` 作为block已经可以使用了，尽管我们没有为QFT定义特别的计算方式，Yao会使用它的矩阵进行计算。\n\n\n```julia\nqft_circuit(x::QFT{N}) where N = qft(N)\nYaoBlocks.mat(x::QFT) = mat(qft_circuit(x))\n```\n\n所以接下来我们来定义具体如何计算QFT\n\n\n```julia\nusing FFTW, LinearAlgebra\n\nfunction YaoBlocks.apply!(r::ArrayReg, x::QFT)\n α = sqrt(length(statevec(r)))\n invorder!(r)\n lmul!(α, ifft!(statevec(r)))\n return r\nend\n```\n\n在Yao里，一个block如何作用在register上的行为是用 `apply!` 函数确定的，也就是说只要为QFT定义了apply函数，我们就可以用FFT来模拟QFT。\n\n现在让我们来检查一下我们定义的QFT和直接用量子线路计算出来的结果是否一致\n\n\n```julia\nr = rand_state(5)\nr1 = r |> copy |> QFT(5)\nr2 = r |> copy |> qft(5)\nr1 ≈ r2\n```\n\n\n\n\n true\n\n\n\n到此为止我们就定义好所有必要的方法了，是不是非常简单？\n\n不过也许你是一个追求完美的人，想让你的QFT block的打印信息好看一些？当然没问题，只要定义下面这个方法就可以了\n\n\n```julia\nYaoBlocks.print_block(io::IO, x::QFT{N}) where N = print(io, \"QFT($N)\")\n```\n\n\n```julia\nQFT(5)\n```\n\n\n\n\n QFT(5)\n\n\n\nYao会自己处理和其它block组合的问题\n\n\n```julia\nchain(QFT(5), put(1=>H))\n```\n\n\n\n\n \u001b[36mnqubits: 5, datatype: Complex{Float64}\u001b[39m\n \u001b[34m\u001b[1mchain\u001b[22m\u001b[39m\n ├─ QFT(5)\n └─ \u001b[36m\u001b[1mput on (\u001b[22m\u001b[39m\u001b[36m\u001b[1m1\u001b[22m\u001b[39m\u001b[36m\u001b[1m)\u001b[22m\u001b[39m\n └─ H gate\n\n\n\n\n亦或者是QFT的逆变换（为什么？想想我们之前讲过的）\n\n\n```julia\nQFT(5)'\n```\n\n\n\n\n \u001b[33m\u001b[1m [†]\u001b[22m\u001b[39mQFT(5)\n\n\n\n## 2.3 相位估计 （Phase Estimation）\n\n我们在上一节封装好了一个QFT block，那么我们接下来就可以用它做一些有用的事情了比如相位估计，相位估计是指下面这个问题：\n\n给定一个作用在m个qubit上的unitary $U$，有 $U |\\psi\\rangle = e^{2\\pi i \\theta}|\\psi\\rangle, \\quad 0 \\leq \\theta < 1$\n\n这个问题可以用这样一个线路来解决，试试自己用Yao定义出来？\n\n\n\n相位估计其实需要两个register，我们按照上面的线路来看看它们都做了什么。\n\n首先对register 1，我们作用了一排H门，这个怎么写？\n\n\n```julia\nPE(n) = chain(n, repeat(H))\n```\n\n\n\n\n PE (generic function with 1 method)\n\n\n\n作用一下\n\n\n```julia\nArrayReg(bit\"00\") |> PE(2) |> state\n```\n\n\n\n\n 4×1 Array{Complex{Float64},2}:\n 0.4999999999999999 + 0.0im\n 0.4999999999999999 + 0.0im\n 0.4999999999999999 + 0.0im\n 0.4999999999999999 + 0.0im\n\n\n\n然后我们来构造一个假的（已知 $\\theta$）态和 U 来看看都发生了什么，分这么几步：\n\n\n```julia\nN, M = 3, 5\n```\n\n\n\n\n (3, 5)\n\n\n\n1. 随机获得一个unitary，然后用本征值求解器找到所有的本征矢\n\n\n```julia\nP = eigen(rand_unitary(1<\n\n但是问题来了，如何只在前n个比特上作用iQFT呢？在Yao里我们定义了 active qubit的概念，所有的block都只作用在当前active的qubit上，我们可以使用 `focus!` 和 `relax!` 函数来调整当前激活的qubit，例如\n\n\n```julia\nr = ArrayReg(bit\"10101\")\n```\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 5/5\n\n\n\n\n```julia\nfocus!(r, 1)\n```\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 1/5\n\n\n\n\n```julia\nr |> X\n```\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 1/5\n\n\n\n\n```julia\nrelax!(r, 1)\n```\n\n\n\n\n ArrayReg{1, Complex{Float64}, Array...}\n active qubits: 5/5\n\n\n\n\n```julia\nstate(r)[bit\"10100\"]\n```\n\n\n\n\n 1.0 + 0.0im\n\n\n\n为了方便你定义线路，Yao还提供了 `concentrate` 这个模块，它会在register进入这个模块的时候进行focus，从而作用较小的模块，然后在作用完毕之后再relax回原来的大小和顺序。所以我们只要把iQFT放进concentrate里面就好了，这样我们的PE线路就可以这么定义\n\n\n```julia\nPE(n, m, U) =\n chain(n+m, repeat(H, 1:n), # H\n chain(control(k, n+1:n+m=>matblock(U^(2^(k-1)))) for k in 1:n), # C-U\n concentrate(QFT(n)', 1:n) # iQFT\n )\n```\n\n\n\n\n PE (generic function with 2 methods)\n\n\n\n最后让我们来验证一下\n\n\n```julia\nr = join(ArrayReg(psi), zero_state(N))\nr |> PE(N, M, U)\nresults = measure(r, 1:N; nshots=1)\n```\n\n\n\n\n 1-element Array{Int64,1}:\n 3\n\n\n\n别忘了我们获得的比特是反的（因为FFT），所以我们来反转一下\n\n\n```julia\nusing BitBasis\nestimated_phase = bfloat(results[]; nbits=N)\n```\n\n\n\n\n 0.75\n\n\n\n### 3 动机 Motivation\n\n- 变分量子线路算法的兴起\n\n- 基于Python的模拟器性能上的劣势\n\n- 易用性和扩展性\n\n### 4 量子体系结构概览\n\n### 5. Yao的设计思路和架构\n\n### 5.1 为算法研究而生\n\n### 5.2 线路的树状表示和IR\n\n### 5.3 利用多重派发进行异构计算\n\n### 5.4 利用多重派发定制线路运行行为\n\n### 5.5 未来和正在进行的工作\n\n### 6. 如何参与Yao的开发\n", "meta": {"hexsha": "1033080893ab61a3c9a7cd240f8c26a1c4d087ac", "size": 822023, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "4_quantum/QC-with-Yao.ipynb", "max_stars_repo_name": "Ben1008611/SSSS", "max_stars_repo_head_hexsha": "ae2932da2096216032789144e95e353f8801d4e0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 165, "max_stars_repo_stars_event_min_datetime": "2019-03-28T08:46:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-20T11:09:52.000Z", "max_issues_repo_path": "4_quantum/QC-with-Yao.ipynb", "max_issues_repo_name": "Ben1008611/SSSS", "max_issues_repo_head_hexsha": "ae2932da2096216032789144e95e353f8801d4e0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2019-03-31T12:15:55.000Z", "max_issues_repo_issues_event_max_datetime": "2019-05-09T09:59:47.000Z", "max_forks_repo_path": "4_quantum/QC-with-Yao.ipynb", "max_forks_repo_name": "Ben1008611/SSSS", "max_forks_repo_head_hexsha": "ae2932da2096216032789144e95e353f8801d4e0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 64, "max_forks_repo_forks_event_min_datetime": "2019-04-22T14:41:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T13:25:09.000Z", "avg_line_length": 200.9836185819, "max_line_length": 354082, "alphanum_fraction": 0.6852569819, "converted": true, "num_tokens": 15459, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3557748798522984, "lm_q2_score": 0.30404167496654744, "lm_q1q2_score": 0.10817039038131497}}
{"text": "# Finite Elements Lecture 1\n\n\n```\nfrom IPython.core.display import HTML\ncss_file = '../ipython_notebook_styles/ngcmstyle.css'\nHTML(open(css_file, \"r\").read())\n```\n\n\n\n\n
\n\n$$\n\\begin{equation}\n\\mathbb{P}( v \\in N_{\\Delta}(x) ) = f(x) \\Delta x \n\\end{equation}\n\\label{eq:mc01} \\tag{1}\n$$\n\n\n\n
\n\nThe histogram approximates the target probability density.
\n\n\n\n\n\n which says that the probability that a sample is in some $N_\\Delta$\nneighborhood of $x$ is approximately $f(x)\\Delta x$. [Figure](#fig:Sampling_Monte_Carlo_000) shows the target probability density function\n$f(x)$ and a histogram that approximates it. The histogram is generated from\nsamples $v$. The hatched rectangle in the center illustrates Equation\nref{eq:mc01}. The area of this rectangle is approximately $f(x)\\Delta x$ where\n$x=0$, in this case. The width of the rectangle is $N_{\\Delta}(x)$ The quality\nof the approximation may be clear visually, but to know that $v$ samples are\ncharacterized by $f(x)$, we need the statement of Equation ref{eq:mc01}, which\nsays that the proportion of samples $v$ that fill the hatched rectangle is\napproximately equal to $f(x)\\Delta x$.\n\nNow that we know how to evaluate samples $v$ that are characterized by the density\n$f(x)$, let's consider how to create these samples for both discrete and\ncontinuous random variables.\n\n## Inverse CDF Method for Discrete Variables\n\nSuppose we want to generate samples from a fair six-sided die. Our workhouse\nuniform random variable is defined continuously over the unit interval and the\nfair six-sided die is discrete. We must first create a mapping between the\ncontinuous random variable $u$ and the discrete outcomes of the die. This\nmapping is shown in [Figure](#fig:Sampling_Monte_Carlo_0001) where the unit\ninterval is broken up into segments, each of length $1/6$. Each individual\nsegment is assigned to one of the die outcomes. For example, if $u \\in\n[1/6,2/6)$, then the outcome for the die is $2$. Because the die is fair, all\nsegments on the unit interval are the same length. Thus, our new random\nvariable $v$ is derived from $u$ by this assignment.\n\n\n\n
\n\nA uniform distribution random variable on the unit interval is assigned to the six outcomes of a fair die using these segements.
\n\n\n\n\n\nFor example, for $v=2$, we have,\n\n$$\n\\mathbb{P}(v=2) = \\mathbb{P}(u\\in [1/6,2/6)) = 1/6\n$$\n\n where, in the language of the Equation ref{eq:mc01}, $f(x)=1$\n(uniform distribution), $\\Delta x = 1/6$, and $N_\\Delta (2)=[1/6,2/6)$.\nNaturally, this pattern holds for all the other die outcomes in\n$\\left\\{1,2,3,..,6\\right\\}$. Let's consider a quick simulation to make this\nconcrete. The following code generates uniform random samples and stacks them\nin a Pandas dataframe.\n\n\n```python\nimport pandas as pd\nimport numpy as np\nfrom pandas import DataFrame\nu= np.random.rand(100)\ndf = DataFrame(data=u,columns=['u'])\n```\n\n The next block uses `pd.cut` to map the individual samples to\nthe set $\\left\\{1,2,\\ldots,6\\right\\}$ labeled `v`.\n\n\n```python\nlabels = [1,2,3,4,5,6]\ndf['v']=pd.cut(df.u,np.linspace(0,1,7),\n include_lowest=True,labels=labels)\n```\n\n This is what the dataframe contains. The `v` column contains\nthe samples drawn from the fair die.\n\n\n```python\n>>> df.head()\n \n```\n\n\n\n\n\n
\n \n \n u \n v \n \n \n \n \n 0 \n 0.605368 \n 4 \n \n \n 1 \n 0.525941 \n 4 \n \n \n 2 \n 0.141985 \n 1 \n \n \n 3 \n 0.729510 \n 5 \n \n \n 4 \n 0.240505 \n 2 \n \n \n
\n
\n
\n \n \n u \n \n \n v \n \n \n \n \n 1 \n 19 \n \n \n 2 \n 15 \n \n \n 3 \n 15 \n \n \n 4 \n 16 \n \n \n 5 \n 23 \n \n \n 6 \n 12 \n \n \n
\n
\n
\n \n \n u \n \n \n v \n \n \n \n \n 1 \n 0.05 \n \n \n 2 \n 0.14 \n \n \n 3 \n 0.07 \n \n \n 4 \n 0.23 \n \n \n 5 \n 0.32 \n \n \n 6 \n 0.19 \n \n \n
\n
\n\nThe samples created using the inverse cdf method match the exponential reference distribution.
\n\n\n\n\n\n## Rejection Method\n\nIn some cases, inverting the CDF may be impossible. The *rejection*\nmethod can handle this situation. The idea is to pick two uniform random\nvariables $u_1,u_2 \\sim \\mathcal{U}[a,b]$ so that\n\n$$\n\\mathbb{P}\\left(u_1 \\in N_{\\Delta}(x) \\bigwedge u_2 < \\frac{f(u_1)}{M} \\right) \\hspace{0.5em} \\approx \\frac{\\Delta x}{b-a} \\frac{f(u_1)}{M}\n$$\n\n where we take $x=u_1$ and $f(x) < M $. This is a two-step process.\nFirst, draw $u_1$ uniformly from the interval $[a,b]$. Second, feed it into\n$f(x)$ and if $u_2 < f(u_1)/M$, then you have a valid sample for $f(x)$. Thus,\n$u_1$ is the proposed sample from $f$ that may or may not be rejected depending\non $u_2$. The only job of the $M$ constant is to scale down the $f(x)$ so that\nthe $u_2$ variable can span the range. The *efficiency* of this method is the\nprobability of accepting $u_1$ which comes from integrating out the above\napproximation,\n\n$$\n\\int \\frac{f(x)}{M(b-a)} dx = \\frac{1}{M(b-a)} \\int f(x)dx =\\frac{1}{M(b-a)}\n$$\n\n This means that we don't want an unecessarily large $M$ because that\nmakes it more likely that samples will be discarded. \n\nLet's try this method for a density that does not have a continuous inverse [^normalization]. \n\n[^normalization]: Note that this example density does not *exactly* integrate\nout to one like a probability density function should, but the normalization\nconstant for this is distracting for our purposes here.\n\n$$\nf(x) = \\exp\\left(-\\frac{(x-1)^2}{2x} \\right) (x+1)/12\n$$\n\n where $x>0$. The following code implements the rejection plan.\n\n\n```python\nimport numpy as np\nx = np.linspace(0.001,15,100)\nf= lambda x: np.exp(-(x-1)**2/2./x)*(x+1)/12.\nfx = f(x)\nM=0.3 # scale factor\nu1 = np.random.rand(10000)*15 # uniform random samples scaled out\nu2 = np.random.rand(10000) # uniform random samples\nidx,= np.where(u2<=f(u1)/M) # rejection criterion\nv = u1[idx]\n```\n\n\n```python\nfig,ax=subplots()\nfig.set_size_inches((9,5))\n_=ax.hist(v,normed=1,bins=40,alpha=.3,color='gray')\n_=ax.plot(x,fx,'k',lw=3.,label='$f(x)$')\n_=ax.set_title('Estimated Efficency=%3.1f%%'%(100*len(v)/len(u1)),\n fontsize=18)\n_=ax.legend(fontsize=18)\n_=ax.set_xlabel('$x$',fontsize=24)\nfig.tight_layout()\n#fig.savefig('fig-probability/Sampling_Monte_Carlo_007.png')\n```\n\n [Figure](#fig:Sampling_Monte_Carlo_007) shows a histogram of the\nso-generated samples that nicely fits the probability density function. The\ntitle in the figure shows the efficiency, which is poor. It means that we threw\naway most of the proposed samples. Thus, even though there is nothing\nconceptually wrong with this result, the low efficiency must be fixed, as a\npractical matter. [Figure](#fig:Sampling_Monte_Carlo_008) shows where the\nproposed samples were rejected. Samples under the curve were retained (i.e.,\n$u_2 < \\frac{f(u_1)}{M}$) but the vast majority of the samples are outside this\numbrella.\n\n\n\n
\n\nThe rejection method generate samples in the histogram that nicely match the target distribution. Unfortunately, the efficiency is not so good.
\n\n\n\n\n\n```python\nfig,ax=subplots()\nfig.set_size_inches((9,5))\n_=ax.plot(u1,u2,'+',label='rejected',alpha=.3,color='gray')\n_=ax.plot(u1[idx],u2[idx],'.',label='accepted',alpha=.3,color='k')\n_=ax.legend(fontsize=22)\nfig.tight_layout()\n#fig.savefig('fig-probability/Sampling_Monte_Carlo_008.png')\n```\n\n\n\n
\n\nThe proposed samples under the curve were accepted and the others were not. This shows the majority of samples were rejected.
\n\n\n\n\n\nThe rejection method uses $u_1$ to select along the domain of $f(x)$ and the\nother $u_2$ uniform random variable decides whether to accept or not. One idea\nwould be to choose $u_1$ so that $x$ values are coincidentally those that are\nnear the peak of $f(x)$, instead of uniformly anywhere in the domain,\nespecially near the tails, which are low probability anyway. Now, the trick is\nto find a new density function $g(x)$ to sample from that has a similiar\nconcentration of probability density. One way it to familiarize oneself with\nthe probability density functions that have adjustable parameters and fast random\nsample generators already. There are lots of places to look and, chances are,\nthere is likely already such a generator for your problem. Otherwise, the\nfamily of $\\beta$ densities is a good place to start. \n\nTo be explicit, what we want is $u_1 \\sim g(x)$ so that, returning to our\nearlier argument,\n\n$$\n\\mathbb{P}\\left( u_1 \\in N_{\\Delta}(x) \\bigwedge u_2 < \\frac{f(u_1)}{M} \\right) \\approx g(x) \\Delta x \\frac{f(u_1)}{M}\n$$\n\n but this is *not* what we need here. The problem is with the\nsecond part of the logical $\\bigwedge$ conjunction. We need to put\nsomething there that will give us something proportional to $f(x)$.\nLet us define the following,\n\n\n
\n\n$$\n\\begin{equation}\n h(x) = \\frac{f(x)}{g(x)} \n\\end{equation}\n\\label{eq:rej01} \\tag{2}\n$$\n\n with corresponding maximum on the domain as $h_{\\max}$ and\nthen go back and construct the second part of the clause as\n\n$$\n\\mathbb{P}\\left(u_1 \\in N_{\\Delta}(x) \\bigwedge u_2 < \\frac{h(u_1)}{h_{\\max}} \\right) \\approx g(x) \\Delta x \\frac{h(u_1)}{h_{\\max}} = f(x)/h_{\\max}\n$$\n\n Recall that satisfying this criterion means that $u_1=x$. As before,\nwe can estimate the probability of acceptance of the $u_1$ as $1/h_{\\max}$.\n\nNow, how to construct the $g(x)$ function in the denominator of Equation\nref{eq:rej01}? Here's where familarity with some standard probability densities\npays off. For this case, we choose the chi-squared distribution. The following\nplots the $g(x)$ and $f(x)$ (left plot) and the corresponding $h(x)=f(x)/g(x)$\n(right plot). Note that $g(x)$ and $f(x)$ have peaks that almost coincide,\nwhich is what we are looking for.\n\n\n```python\nch=scipy.stats.chi2(4) # chi-squared\nh = lambda x: f(x)/ch.pdf(x) # h-function\n```\n\n\n```python\nfig,axs=subplots(1,2,sharex=True)\nfig.set_size_inches(12,4)\n_=axs[0].plot(x,fx,label='$f(x)$',color='k')\n_=axs[0].plot(x,ch.pdf(x),'--',lw=2,label='$g(x)$',color='gray')\n_=axs[0].legend(loc=0,fontsize=24)\n_=axs[0].set_xlabel(r'$x$',fontsize=22)\n_=axs[1].plot(x,h(x),'-k',lw=3)\n_=axs[1].set_title('$h(x)=f(x)/g(x)$',fontsize=24)\n_=axs[1].set_xlabel(r'$x$',fontsize=22)\nfig.tight_layout()\n#fig.savefig('fig-probability/Sampling_Monte_Carlo_009.png')\n```\n\n\n\n
\n\nThe plot on the right shows $h(x)=f(x)/g(x)$ and the one on the left shows $f(x)$ and $g(x)$ separately.
\n\n\n\n\n\n Now, let's generate some samples from this $\\chi^2$\ndistribution with the rejection method.\n\n\n```python\nhmax=h(x).max()\nu1 = ch.rvs(5000) # samples from chi-square distribution\nu2 = np.random.rand(5000)# uniform random samples\nidx = (u2 <= h(u1)/hmax) # rejection criterion\nv = u1[idx] # keep these only\n```\n\n\n```python\nfig,ax=subplots()\nfig.set_size_inches((7,3))\n_=ax.hist(v,normed=1,bins=40,alpha=.3,color='gray')\n_=ax.plot(x,fx,color='k',lw=3.,label='$f(x)$')\n_=ax.set_title('Estimated Efficency=%3.1f%%'%(100*len(v)/len(u1)))\n_=ax.axis(xmax=15)\n_=ax.legend(fontsize=18)\n#fig.savefig('fig-probability/Sampling_Monte_Carlo_010.png')\n```\n\n\n\n
\n\nUsing the updated method, the histogram matches the target probability density function with high efficiency.
\n\n\n\n\n\nUsing the $\\chi^2$ distribution with the rejection method results in throwing\naway less than 10% of the generated samples compared with our prior example\nwhere we threw out at least 80%. This is dramatically more\nefficient. [Figure](#fig:Sampling_Monte_Carlo_010) shows that the histogram\nand the probability density function match. For completeness, [Figure](#fig:Sampling_Monte_Carlo_011) shows the samples with the corresponding\nthreshold $h(x)/h_{\\max}$ that was used to select them.\n\n\n```python\nfig,ax=subplots()\nfig.set_size_inches((7,4))\n_=ax.plot(u1,u2,'+',label='rejected',alpha=.3,color='gray')\n_=ax.plot(u1[idx],u2[idx],'g.',label='accepted',alpha=.3,color='k')\n_=ax.plot(x,h(x)/hmax,color='k',lw=3.,label='$h(x)$')\n_=ax.legend(fontsize=16,loc=0) \n_=ax.set_xlabel('$x$',fontsize=24)\n_=ax.set_xlabel('$h(x)$',fontsize=24)\n_=ax.axis(xmax=15,ymax=1.1)\nfig.tight_layout()\n#fig.savefig('fig-probability/Sampling_Monte_Carlo_011.png')\n```\n\n\n\n
\n\nFewer proposed points were rejected in this case, which means better efficiency.
\n\n\n\n\n\nIn this section, we investigated how to generate random samples from a given\ndistribution, beit discrete or continuous. For the continuous case, the key\nissue was whether or not the cumulative density function had a continuous\ninverse. If not, we had to turn to the rejection method, and find an\nappropriate related density that we could easily sample from to use as part of\na rejection threshold. Finding such a function is an art, but many families of\nprobability densities have been studied over the years that already have fast\nrandom number generators.\n\nThe rejection method has many complicated extensions that involve careful\npartitioning of the domains and lots of special methods for corner cases.\nNonetheless, all of these advanced techniques are still variations on the same\nfundamental theme we illustrated here [[dunn2011exploring]](#dunn2011exploring),[[johnson1995continuous]](#johnson1995continuous).\n", "meta": {"hexsha": "9f6bd05b8f84b5934cd9261de379476b97c2b4b5", "size": 706141, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapters/probability/notebooks/Sampling_Monte_Carlo.ipynb", "max_stars_repo_name": "nsydn/Python-for-Probability-Statistics-and-Machine-Learning", "max_stars_repo_head_hexsha": "d3e0f8ea475525a694a975dbfd2bf80bc2967cc6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 570, "max_stars_repo_stars_event_min_datetime": "2016-05-05T19:08:27.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T05:09:19.000Z", "max_issues_repo_path": "chapters/probability/notebooks/Sampling_Monte_Carlo.ipynb", "max_issues_repo_name": "crlsmcl/https-github.com-unpingco-Python-for-Probability-Statistics-and-Machine-Learning", "max_issues_repo_head_hexsha": "6fd69459a28c0b76b37fad79b7e8e430d09a86a5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2, "max_issues_repo_issues_event_min_datetime": "2016-05-12T22:18:58.000Z", "max_issues_repo_issues_event_max_datetime": "2019-11-06T14:37:06.000Z", "max_forks_repo_path": "chapters/probability/notebooks/Sampling_Monte_Carlo.ipynb", "max_forks_repo_name": "crlsmcl/https-github.com-unpingco-Python-for-Probability-Statistics-and-Machine-Learning", "max_forks_repo_head_hexsha": "6fd69459a28c0b76b37fad79b7e8e430d09a86a5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 276, "max_forks_repo_forks_event_min_datetime": "2016-05-27T01:42:05.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T11:20:27.000Z", "avg_line_length": 409.1199304751, "max_line_length": 220340, "alphanum_fraction": 0.9068712906, "converted": true, "num_tokens": 6682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48828339529583464, "lm_q2_score": 0.22000710486009023, "lm_q1q2_score": 0.10742581615029158}}
{"text": "```python\n%matplotlib notebook\n%matplotlib inline\nimport math\nimport matplotlib.pyplot as plt\n```\n\n\n# Nuclear Power Economics and Fuel Management\n\n\n\n## Syllabus\n\nThroughout the semester, you can always find the syllabus online at [https://github.com/katyhuff/npre412/blob/master/syllabus/syllabus.pdf](https://github.com/katyhuff/npre412/blob/master/syllabus/syllabus.pdf).\n\n\n```python\nfrom IPython.display import IFrame\nIFrame(\"../syllabus/syllabus.pdf\", width=1000, height=1000)\n```\n\n\n\n\n\n\n\n\n\n\n\n```python\nfrom IPython.display import IFrame\nIFrame(\"http://katyhuff.github.io\", width=1000, height=700)\n```\n\n\n\n\n\n\n\n\n\n\n## Assessment\n\n\nMy goal (and, hopefully your goal) is for you to learn this material. If I have done my job right, your grade in this class will reflect just that -- how much you have learned. To do this for many learning types, your comprehension of the readings will be assessed with quizzes, your ability to apply what you've learned from class on your own will be assessed with the homeworks and projects, and your wholistic retention of the material will be assessed with tests.\n\n\n\n\n### Monday Background Reading Assignments\n\nRather than introducing you to concepts during class, I think our time is better spent if we focus on exploring those concepts through demonstration and discussion together. **This 'active learning' educational strategy is backed by science, but is also just more respectful of your ability to learn things on your own.** Therefore, the lectures will assume you have studied the background materials ahead of time. This will include book sections, government reports, videos, and other resources. You will be expected to study the material outside of class before the start of each week. This will include book sections, government reports, videos, and other resources. I recommend you take notes on this material as it may be part of the tests.\n\n**On Monday of each week I'll assign a list of material. You'll have 7 days to study that material before we start covering those concepts in class.**\n\n\n\n### Monday Quizzes\n\nTo help me calibrate the in-class discussion, a weekly quiz will assess your comprehension of the background material. The quizzes can be taken online through [Compass2g](https://compass2g.illinois.edu) at any time during the week, but they must be completed by Monday at 10am, 7 days after the material was assigned.\n\n### Friday Homework Assignments\n\nHomeworks will be assigned each Friday concerning the material covered that week. You will have 7 days to do the homework, so it will be due at 10am on the following Friday. You'll notice that my office hours are also on Friday. This is intentional, because I feel office hours are most effective if you come to them after handing in your homework to discuss the parts that you didn't get. \n\n### Projects\n\nThe class will involve a longer project only assigned to graduate students. \n\n### Tests\n\nThe midterms will take place in class. They will be independent of one another. The final will be comprehensive.\n\n### Participation\n\nI will notice when you are not in class, but attendance won't directly affect your grades. It may, however, indirectly affect your grades. If you miss something I demonstrate in class, you'll have a lot more trouble proving that you've learned it. \n\n## How to get an A\n\nMy dear friend, mathematician Kathryn Mann, has a great summary of [how to get an A in her class.](https://math.berkeley.edu/~kpmann/getanA.pdf). Everything she says about her math classes is true for this class as well. You should expect to spend 3 hours outside of class for every hour you spend in class. So, for a 3 credit class, you'll need to spend 3 hours a week in class and 9 hours outside of class on the coursework. If you find you're spending much less or much more time on this class, please let me know. \n\n## Late Work\n\n**Late work has a halflife of 1 hour.** That is, adjusted for lateness, your grade $G(t)$ is a decaying percentage of the raw grade $G_0$. An assignment turned in $t$ hours late will recieve a grade according to the following relation:\n\n$$\n\\begin{align}\n G(t) &= G_0e^{-\\lambda t}\\\\\n\\end{align}\n$$\n\nwhere\n\n$$\n\\begin{align}\n G(t) &= \\mbox{grade adjusted for lateness}\\\\\n G_0 &= \\mbox{raw grade}\\\\\n \\lambda &= \\frac{ln(2)}{t_{1/2}} = \\mbox{decay constant} \\\\\n t &= \\mbox{time elapsed since due [hours]}\\\\\n t_{1/2} &= 1 = \\mbox{half-life [hours]} \\\\\n\\end{align}\n$$\n\n\n```python\nimport math\ndef late_grade(hours_late, grade=100, half_life=1):\n \"\"\"This function describes how much credit you will get for late work\"\"\"\n lam = math.log(2)/half_life\n return grade*math.exp(-lam*hours_late)\n```\n\n\n```python\n# This code plots how much credit you'll get over time\nimport numpy as np\ny = np.arange(24)\nx = np.arange(24)\nfor h in range(0,24):\n x[h] = h\n y[h] = late_grade(h)\n \n# creates a figure and axes with matplotlib\nfig, ax = plt.subplots()\nscatter = plt.scatter(x, y, color='blue', s=y*20, alpha=0.4) \nax.plot(x, y, color='red') \n\n# adds labels to the plot\nax.set_ylabel('Percent of Grade Earned')\nax.set_xlabel('Hours Late')\nax.set_title('Grade Decay')\n\n# adds tooltips\nimport mpld3\nlabels = ['{0}% earned'.format(i) for i in y]\ntooltip = mpld3.plugins.PointLabelTooltip(scatter, labels=labels)\nmpld3.plugins.connect(fig, tooltip)\n\nmpld3.display()\n```\n\n\n\n\n\n\n\n\n
\n\n\n\n\n\n```python\nprint(\"If you turn in your homework an hour late, you'll get \", round(late_grade(1),2), \"% credit.\")\nprint(\"If you turn in your homework six hours late, you'll get \", round(late_grade(6),2), \"% credit.\")\nprint(\"If you turn in your homework a day late, you'll get \", round(late_grade(24),2), \"% credit.\")\nprint(\"If you turn in your homework two days late, you'll get \", round(late_grade(48),2), \"% credit.\")\nprint(\"If you turn in your homework three days late, you'll get \", round(late_grade(72),2), \"% credit.\")\n```\n\n If you turn in your homework an hour late, you'll get 50.0 % credit.\n If you turn in your homework six hours late, you'll get 1.56 % credit.\n If you turn in your homework a day late, you'll get 0.0 % credit.\n If you turn in your homework two days late, you'll get 0.0 % credit.\n If you turn in your homework three days late, you'll get 0.0 % credit.\n\n\n**There will be no negotiation about late work except in the case of absence documented by an absence letter from the Dean of Students.** The university policy for requesting such a letter is [here](http://studentcode.illinois.edu/article1_part5_1-501.html) . Please note that such a letter is appropriate for many types of conflicts, but that religious conflicts require special early handling. In accordance with university policy, students seeking an excused absence for religious reasons should complete the Request for Accommodation for Religious Observances Form, which can be found on the Office of the Dean of Students website. The student should submit this form to the instructor and the Office of the Dean of Students by the end of the second week of the course to which it applies.\n\n## Communications\n\n\nThings to try when you have a question:\n\n- Be Persistent: [Try just one more time.](https://s-media-cache-ak0.pinimg.com/736x/03/54/ce/0354ce58a7a4308edcc46dd9238e12d7.jpg)\n- Google: [You might be surprised at its depth.](https://devhumor.com/content/uploads//images/April2016/google-errors.jpg)\n- Piazza: Try this first, your student colleagues probably know the answer.\n- TA email: A quick question can usually be answered by your TA via email.\n- TA office hours: Your TA is there for you at a regularly scheduled time.\n- Prof. email: Questions not appropriate for your TA can be directed to me.\n- Prof. office hours: I will be in my office once a week for your convenience.\n- Prof. appointment: For private matters or when office hours conflict with your schedule, schedule an appointment with me.\n\n### A note on email\n\n[Email tips for dealing with fussy professor types.](https://medium.com/@lportwoodstacer/how-to-email-your-professor-without-being-annoying-af-cf64ae0e4087)\n\n## Python, IPython, Jupyter, git, and the Notebooks\n\nRather than reading equations off of slides, I will display lecture notes, equations, and images in \"Jupyter notebooks\" like this one. Sometimes, I will call them by their old name, \"IPython notebooks,\" but I'm talking about \"Jupyter notebooks\". Interleaved with the course notes, we will often write small functions in the Python programming language to represent the equations we are talking about. This will allow you to interact with the math, changing variables, modifying the models, and exploring the parameter space. \n\n### But I don't know Python!\n\n*You don't have to know Python to take this class.* However, you will need to learn a little along the way. I will provide lots of example code to support your completion of homework assignments and I will never ask you to write functioning code as part of any written exam. Programming is really hard without the internet. \n\n### Exercises\n\nWatch for blocks titled **Exercise** in the notebooks. Those mark moments when I will ask you, during class, to try something out, explore an equation, or arrive at an answer. These are short and are not meant to be difficult. They exist to quickly solidify an idea before we move on to the next one. I will often randomly call on students (with a random number generator populated with the enrollment list) to give solutions to the exercises, so **a failure to show up and participate will be noticed.** \n\n### Installing Python, IPython, Jupyter, git, and the Notebooks\n\nBecause engaging in the exercises will be really helpful for you to study, you'll should try to gain access to a computer equipped with Python (a version greater than 3.0) and a basic set of scientific python libraries. If you have a computer already, I encourage you to install [anaconda](https://www.continuum.io/downloads).\n\nThese notebooks are stored \"in the cloud,\" which is to say that they are stored on someone else's computers. Those computers are servers at GitHub, a sometimes silly but also very important company in the beautiful city of San Francisco. GitHub stores \"git repositories\" which are collections of files that are \"version controlled\" by the program \"git.\" This is a lot to keep track of, and I won't require that you learn git to participate in this class. However, I strongly recommend using git and GitHub and to keep track of your research code. So, I encourage you to use git to access the notebooks. \n\n**More information about the things you might want to install can be found in the [README](https://github.com/katyhuff/npre412/blob/master/README.md).**\n\n\n\n\n\n\n\n", "meta": {"hexsha": "38bda0263be6f2d51a410bbdfeb3b81139d6640f", "size": 32542, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "introduction/00-intro-syllabus.ipynb", "max_stars_repo_name": "atomicaristides/NPRE412", "max_stars_repo_head_hexsha": "b2ae552303f3e4894628c8401d3bedd2db85a551", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "introduction/00-intro-syllabus.ipynb", "max_issues_repo_name": "atomicaristides/NPRE412", "max_issues_repo_head_hexsha": "b2ae552303f3e4894628c8401d3bedd2db85a551", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "introduction/00-intro-syllabus.ipynb", "max_forks_repo_name": "atomicaristides/NPRE412", "max_forks_repo_head_hexsha": "b2ae552303f3e4894628c8401d3bedd2db85a551", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 81.5588972431, "max_line_length": 5105, "alphanum_fraction": 0.573689386, "converted": true, "num_tokens": 2561, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.40356685373537454, "lm_q2_score": 0.2658804672827598, "lm_q1q2_score": 0.10730054365099458}}
{"text": "##### Copyright 2020 The TensorFlow Authors.\n\n\n```\n#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n```\n\n# Quantum Convolutional Neural Network\n\n\n\nThis tutorial implements a simplified Quantum Convolutional Neural Network (QCNN), a proposed quantum analogue to a classical convolutional neural network that is also *translationally invariant*.\n\nThis example demonstrates how to detect certain properties of a quantum data source, such as a quantum sensor or a complex simulation from a device. The quantum data source being a cluster state that may or may not have an excitation—what the QCNN will learn to detect (The dataset used in the paper was SPT phase classification).\n\n## Setup\n\n\n```\n!pip install tensorflow==2.3.1\n```\n\nInstall TensorFlow Quantum:\n\n\n```\n!pip install tensorflow-quantum\n```\n\nNow import TensorFlow and the module dependencies:\n\n\n```\nimport tensorflow as tf\nimport tensorflow_quantum as tfq\n\nimport cirq\nimport sympy\nimport numpy as np\n\n# visualization tools\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom cirq.contrib.svg import SVGCircuit\n```\n\n## 1. Build a QCNN\n\n### 1.1 Assemble circuits in a TensorFlow graph\n\nTensorFlow Quantum (TFQ) provides layer classes designed for in-graph circuit construction. One example is the `tfq.layers.AddCircuit` layer that inherits from `tf.keras.Layer`. This layer can either prepend or append to the input batch of circuits, as shown in the following figure.\n\n\n\nThe following snippet uses this layer:\n\n\n```\nqubit = cirq.GridQubit(0, 0)\n\n# Define some circuits.\ncircuit1 = cirq.Circuit(cirq.X(qubit))\ncircuit2 = cirq.Circuit(cirq.H(qubit))\n\n# Convert to a tensor.\ninput_circuit_tensor = tfq.convert_to_tensor([circuit1, circuit2])\n\n# Define a circuit that we want to append\ny_circuit = cirq.Circuit(cirq.Y(qubit))\n\n# Instantiate our layer\ny_appender = tfq.layers.AddCircuit()\n\n# Run our circuit tensor through the layer and save the output.\noutput_circuit_tensor = y_appender(input_circuit_tensor, append=y_circuit)\n```\n\nExamine the input tensor:\n\n\n```\nprint(tfq.from_tensor(input_circuit_tensor))\n```\n\nAnd examine the output tensor:\n\n\n```\nprint(tfq.from_tensor(output_circuit_tensor))\n```\n\nWhile it is possible to run the examples below without using `tfq.layers.AddCircuit`, it's a good opportunity to understand how complex functionality can be embedded into TensorFlow compute graphs.\n\n### 1.2 Problem overview\n\nYou will prepare a *cluster state* and train a quantum classifier to detect if it is \"excited\" or not. The cluster state is highly entangled but not necessarily difficult for a classical computer. For clarity, this is a simpler dataset than the one used in the paper.\n\nFor this classification task you will implement a deep MERA -like QCNN architecture since:\n\n1. Like the QCNN, the cluster state on a ring is translationally invariant.\n2. The cluster state is highly entangled.\n\nThis architecture should be effective at reducing entanglement, obtaining the classification by reading out a single qubit.\n\n\n\nAn \"excited\" cluster state is defined as a cluster state that had a `cirq.rx` gate applied to any of its qubits. Qconv and QPool are discussed later in this tutorial.\n\n### 1.3 Building blocks for TensorFlow\n\n\n\nOne way to solve this problem with TensorFlow Quantum is to implement the following:\n\n1. The input to the model is a circuit tensor—either an empty circuit or an X gate on a particular qubit indicating an excitation.\n2. The rest of the model's quantum components are constructed with `tfq.layers.AddCircuit` layers.\n3. For inference a `tfq.layers.PQC` layer is used. This reads $\\langle \\hat{Z} \\rangle$ and compares it to a label of 1 for an excited state, or -1 for a non-excited state.\n\n### 1.4 Data\nBefore building your model, you can generate your data. In this case it's going to be excitations to the cluster state (The original paper uses a more complicated dataset). Excitations are represented with `cirq.rx` gates. A large enough rotation is deemed an excitation and is labeled `1` and a rotation that isn't large enough is labeled `-1` and deemed not an excitation.\n\n\n```\ndef generate_data(qubits):\n \"\"\"Generate training and testing data.\"\"\"\n n_rounds = 20 # Produces n_rounds * n_qubits datapoints.\n excitations = []\n labels = []\n for n in range(n_rounds):\n for bit in qubits:\n rng = np.random.uniform(-np.pi, np.pi)\n excitations.append(cirq.Circuit(cirq.rx(rng)(bit)))\n labels.append(1 if (-np.pi / 2) <= rng <= (np.pi / 2) else -1)\n\n split_ind = int(len(excitations) * 0.7)\n train_excitations = excitations[:split_ind]\n test_excitations = excitations[split_ind:]\n\n train_labels = labels[:split_ind]\n test_labels = labels[split_ind:]\n\n return tfq.convert_to_tensor(train_excitations), np.array(train_labels), \\\n tfq.convert_to_tensor(test_excitations), np.array(test_labels)\n```\n\nYou can see that just like with regular machine learning you create a training and testing set to use to benchmark the model. You can quickly look at some datapoints with:\n\n\n```\nsample_points, sample_labels, _, __ = generate_data(cirq.GridQubit.rect(1, 4))\nprint('Input:', tfq.from_tensor(sample_points)[0], 'Output:', sample_labels[0])\nprint('Input:', tfq.from_tensor(sample_points)[1], 'Output:', sample_labels[1])\n```\n\n### 1.5 Define layers\n\nNow define the layers shown in the figure above in TensorFlow.\n\n#### 1.5.1 Cluster state\n\nThe first step is to define the cluster state using Cirq , a Google-provided framework for programming quantum circuits. Since this is a static part of the model, embed it using the `tfq.layers.AddCircuit` functionality.\n\n\n```\ndef cluster_state_circuit(bits):\n \"\"\"Return a cluster state on the qubits in `bits`.\"\"\"\n circuit = cirq.Circuit()\n circuit.append(cirq.H.on_each(bits))\n for this_bit, next_bit in zip(bits, bits[1:] + [bits[0]]):\n circuit.append(cirq.CZ(this_bit, next_bit))\n return circuit\n```\n\nDisplay a cluster state circuit for a rectangle of cirq.GridQubitCong and Lukin QCNN paper . There are a few prerequisites:\n\n* The one- and two-qubit parameterized unitary matrices from the Tucci paper .\n* A general parameterized two-qubit pooling operation.\n\n\n```\ndef one_qubit_unitary(bit, symbols):\n \"\"\"Make a Cirq circuit enacting a rotation of the bloch sphere about the X,\n Y and Z axis, that depends on the values in `symbols`.\n \"\"\"\n return cirq.Circuit(\n cirq.X(bit)**symbols[0],\n cirq.Y(bit)**symbols[1],\n cirq.Z(bit)**symbols[2])\n\n\ndef two_qubit_unitary(bits, symbols):\n \"\"\"Make a Cirq circuit that creates an arbitrary two qubit unitary.\"\"\"\n circuit = cirq.Circuit()\n circuit += one_qubit_unitary(bits[0], symbols[0:3])\n circuit += one_qubit_unitary(bits[1], symbols[3:6])\n circuit += [cirq.ZZ(*bits)**symbols[6]]\n circuit += [cirq.YY(*bits)**symbols[7]]\n circuit += [cirq.XX(*bits)**symbols[8]]\n circuit += one_qubit_unitary(bits[0], symbols[9:12])\n circuit += one_qubit_unitary(bits[1], symbols[12:])\n return circuit\n\n\ndef two_qubit_pool(source_qubit, sink_qubit, symbols):\n \"\"\"Make a Cirq circuit to do a parameterized 'pooling' operation, which\n attempts to reduce entanglement down from two qubits to just one.\"\"\"\n pool_circuit = cirq.Circuit()\n sink_basis_selector = one_qubit_unitary(sink_qubit, symbols[0:3])\n source_basis_selector = one_qubit_unitary(source_qubit, symbols[3:6])\n pool_circuit.append(sink_basis_selector)\n pool_circuit.append(source_basis_selector)\n pool_circuit.append(cirq.CNOT(control=source_qubit, target=sink_qubit))\n pool_circuit.append(sink_basis_selector**-1)\n return pool_circuit\n```\n\nTo see what you created, print out the one-qubit unitary circuit:\n\n\n```\nSVGCircuit(one_qubit_unitary(cirq.GridQubit(0, 0), sympy.symbols('x0:3')))\n```\n\nAnd the two-qubit unitary circuit:\n\n\n```\nSVGCircuit(two_qubit_unitary(cirq.GridQubit.rect(1, 2), sympy.symbols('x0:15')))\n```\n\nAnd the two-qubit pooling circuit:\n\n\n```\nSVGCircuit(two_qubit_pool(*cirq.GridQubit.rect(1, 2), sympy.symbols('x0:6')))\n```\n\n##### 1.5.2.1 Quantum convolution\n\nAs in the Cong and Lukin paper, define the 1D quantum convolution as the application of a two-qubit parameterized unitary to every pair of adjacent qubits with a stride of one.\n\n\n```\ndef quantum_conv_circuit(bits, symbols):\n \"\"\"Quantum Convolution Layer following the above diagram.\n Return a Cirq circuit with the cascade of `two_qubit_unitary` applied\n to all pairs of qubits in `bits` as in the diagram above.\n \"\"\"\n circuit = cirq.Circuit()\n for first, second in zip(bits[0::2], bits[1::2]):\n circuit += two_qubit_unitary([first, second], symbols)\n for first, second in zip(bits[1::2], bits[2::2] + [bits[0]]):\n circuit += two_qubit_unitary([first, second], symbols)\n return circuit\n```\n\nDisplay the (very horizontal) circuit:\n\n\n```\nSVGCircuit(\n quantum_conv_circuit(cirq.GridQubit.rect(1, 8), sympy.symbols('x0:15')))\n```\n\n##### 1.5.2.2 Quantum pooling\n\nA quantum pooling layer pools from $N$ qubits to $\\frac{N}{2}$ qubits using the two-qubit pool defined above.\n\n\n```\ndef quantum_pool_circuit(source_bits, sink_bits, symbols):\n \"\"\"A layer that specifies a quantum pooling operation.\n A Quantum pool tries to learn to pool the relevant information from two\n qubits onto 1.\n \"\"\"\n circuit = cirq.Circuit()\n for source, sink in zip(source_bits, sink_bits):\n circuit += two_qubit_pool(source, sink, symbols)\n return circuit\n```\n\nExamine a pooling component circuit:\n\n\n```\ntest_bits = cirq.GridQubit.rect(1, 8)\n\nSVGCircuit(\n quantum_pool_circuit(test_bits[:4], test_bits[4:], sympy.symbols('x0:6')))\n```\n\n### 1.6 Model definition\n\nNow use the defined layers to construct a purely quantum CNN. Start with eight qubits, pool down to one, then measure $\\langle \\hat{Z} \\rangle$.\n\n\n```\ndef create_model_circuit(qubits):\n \"\"\"Create sequence of alternating convolution and pooling operators \n which gradually shrink over time.\"\"\"\n model_circuit = cirq.Circuit()\n symbols = sympy.symbols('qconv0:63')\n # Cirq uses sympy.Symbols to map learnable variables. TensorFlow Quantum\n # scans incoming circuits and replaces these with TensorFlow variables.\n model_circuit += quantum_conv_circuit(qubits, symbols[0:15])\n model_circuit += quantum_pool_circuit(qubits[:4], qubits[4:],\n symbols[15:21])\n model_circuit += quantum_conv_circuit(qubits[4:], symbols[21:36])\n model_circuit += quantum_pool_circuit(qubits[4:6], qubits[6:],\n symbols[36:42])\n model_circuit += quantum_conv_circuit(qubits[6:], symbols[42:57])\n model_circuit += quantum_pool_circuit([qubits[6]], [qubits[7]],\n symbols[57:63])\n return model_circuit\n\n\n# Create our qubits and readout operators in Cirq.\ncluster_state_bits = cirq.GridQubit.rect(1, 8)\nreadout_operators = cirq.Z(cluster_state_bits[-1])\n\n# Build a sequential model enacting the logic in 1.3 of this notebook.\n# Here you are making the static cluster state prep as a part of the AddCircuit and the\n# \"quantum datapoints\" are coming in the form of excitation\nexcitation_input = tf.keras.Input(shape=(), dtype=tf.dtypes.string)\ncluster_state = tfq.layers.AddCircuit()(\n excitation_input, prepend=cluster_state_circuit(cluster_state_bits))\n\nquantum_model = tfq.layers.PQC(create_model_circuit(cluster_state_bits),\n readout_operators)(cluster_state)\n\nqcnn_model = tf.keras.Model(inputs=[excitation_input], outputs=[quantum_model])\n\n# Show the keras plot of the model\ntf.keras.utils.plot_model(qcnn_model,\n show_shapes=True,\n show_layer_names=False,\n dpi=70)\n```\n\n### 1.7 Train the model\n\nTrain the model over the full batch to simplify this example.\n\n\n```\n# Generate some training data.\ntrain_excitations, train_labels, test_excitations, test_labels = generate_data(\n cluster_state_bits)\n\n\n# Custom accuracy metric.\n@tf.function\ndef custom_accuracy(y_true, y_pred):\n y_true = tf.squeeze(y_true)\n y_pred = tf.map_fn(lambda x: 1.0 if x >= 0 else -1.0, y_pred)\n return tf.keras.backend.mean(tf.keras.backend.equal(y_true, y_pred))\n\n\nqcnn_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.02),\n loss=tf.losses.mse,\n metrics=[custom_accuracy])\n\nhistory = qcnn_model.fit(x=train_excitations,\n y=train_labels,\n batch_size=16,\n epochs=25,\n verbose=1,\n validation_data=(test_excitations, test_labels))\n```\n\n\n```\nplt.plot(history.history['loss'][1:], label='Training')\nplt.plot(history.history['val_loss'][1:], label='Validation')\nplt.title('Training a Quantum CNN to Detect Excited Cluster States')\nplt.xlabel('Epochs')\nplt.ylabel('Loss')\nplt.legend()\nplt.show()\n```\n\n## 2. Hybrid models\n\nYou don't have to go from eight qubits to one qubit using quantum convolution—you could have done one or two rounds of quantum convolution and fed the results into a classical neural network. This section explores quantum-classical hybrid models.\n\n### 2.1 Hybrid model with a single quantum filter\n\nApply one layer of quantum convolution, reading out $\\langle \\hat{Z}_n \\rangle$ on all bits, followed by a densely-connected neural network.\n\n\n\n#### 2.1.1 Model definition\n\n\n```\n# 1-local operators to read out\nreadouts = [cirq.Z(bit) for bit in cluster_state_bits[4:]]\n\n\ndef multi_readout_model_circuit(qubits):\n \"\"\"Make a model circuit with less quantum pool and conv operations.\"\"\"\n model_circuit = cirq.Circuit()\n symbols = sympy.symbols('qconv0:21')\n model_circuit += quantum_conv_circuit(qubits, symbols[0:15])\n model_circuit += quantum_pool_circuit(qubits[:4], qubits[4:],\n symbols[15:21])\n return model_circuit\n\n\n# Build a model enacting the logic in 2.1 of this notebook.\nexcitation_input_dual = tf.keras.Input(shape=(), dtype=tf.dtypes.string)\n\ncluster_state_dual = tfq.layers.AddCircuit()(\n excitation_input_dual, prepend=cluster_state_circuit(cluster_state_bits))\n\nquantum_model_dual = tfq.layers.PQC(\n multi_readout_model_circuit(cluster_state_bits),\n readouts)(cluster_state_dual)\n\nd1_dual = tf.keras.layers.Dense(8)(quantum_model_dual)\n\nd2_dual = tf.keras.layers.Dense(1)(d1_dual)\n\nhybrid_model = tf.keras.Model(inputs=[excitation_input_dual], outputs=[d2_dual])\n\n# Display the model architecture\ntf.keras.utils.plot_model(hybrid_model,\n show_shapes=True,\n show_layer_names=False,\n dpi=70)\n```\n\n#### 2.1.2 Train the model\n\n\n```\nhybrid_model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.02),\n loss=tf.losses.mse,\n metrics=[custom_accuracy])\n\nhybrid_history = hybrid_model.fit(x=train_excitations,\n y=train_labels,\n batch_size=16,\n epochs=25,\n verbose=1,\n validation_data=(test_excitations,\n test_labels))\n```\n\n\n```\nplt.plot(history.history['val_custom_accuracy'], label='QCNN')\nplt.plot(hybrid_history.history['val_custom_accuracy'], label='Hybrid CNN')\nplt.title('Quantum vs Hybrid CNN performance')\nplt.xlabel('Epochs')\nplt.legend()\nplt.ylabel('Validation Accuracy')\nplt.show()\n```\n\nAs you can see, with very modest classical assistance, the hybrid model will usually converge faster than the purely quantum version.\n\n### 2.2 Hybrid convolution with multiple quantum filters\n\nNow let's try an architecture that uses multiple quantum convolutions and a classical neural network to combine them.\n\n\n\n#### 2.2.1 Model definition\n\n\n```\nexcitation_input_multi = tf.keras.Input(shape=(), dtype=tf.dtypes.string)\n\ncluster_state_multi = tfq.layers.AddCircuit()(\n excitation_input_multi, prepend=cluster_state_circuit(cluster_state_bits))\n\n# apply 3 different filters and measure expectation values\n\nquantum_model_multi1 = tfq.layers.PQC(\n multi_readout_model_circuit(cluster_state_bits),\n readouts)(cluster_state_multi)\n\nquantum_model_multi2 = tfq.layers.PQC(\n multi_readout_model_circuit(cluster_state_bits),\n readouts)(cluster_state_multi)\n\nquantum_model_multi3 = tfq.layers.PQC(\n multi_readout_model_circuit(cluster_state_bits),\n readouts)(cluster_state_multi)\n\n# concatenate outputs and feed into a small classical NN\nconcat_out = tf.keras.layers.concatenate(\n [quantum_model_multi1, quantum_model_multi2, quantum_model_multi3])\n\ndense_1 = tf.keras.layers.Dense(8)(concat_out)\n\ndense_2 = tf.keras.layers.Dense(1)(dense_1)\n\nmulti_qconv_model = tf.keras.Model(inputs=[excitation_input_multi],\n outputs=[dense_2])\n\n# Display the model architecture\ntf.keras.utils.plot_model(multi_qconv_model,\n show_shapes=True,\n show_layer_names=True,\n dpi=70)\n```\n\n#### 2.2.2 Train the model\n\n\n```\nmulti_qconv_model.compile(\n optimizer=tf.keras.optimizers.Adam(learning_rate=0.02),\n loss=tf.losses.mse,\n metrics=[custom_accuracy])\n\nmulti_qconv_history = multi_qconv_model.fit(x=train_excitations,\n y=train_labels,\n batch_size=16,\n epochs=25,\n verbose=1,\n validation_data=(test_excitations,\n test_labels))\n```\n\n\n```\nplt.plot(history.history['val_custom_accuracy'][:25], label='QCNN')\nplt.plot(hybrid_history.history['val_custom_accuracy'][:25], label='Hybrid CNN')\nplt.plot(multi_qconv_history.history['val_custom_accuracy'][:25],\n label='Hybrid CNN \\n Multiple Quantum Filters')\nplt.title('Quantum vs Hybrid CNN performance')\nplt.xlabel('Epochs')\nplt.legend()\nplt.ylabel('Validation Accuracy')\nplt.show()\n```\n", "meta": {"hexsha": "2030cda3cf9e3b402c6c5e0767cfbef820261d3d", "size": 35806, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "site/en-snapshot/quantum/tutorials/qcnn.ipynb", "max_stars_repo_name": "secsilm/docs-l10n", "max_stars_repo_head_hexsha": "2acda8cb1671a826f44115e2fa6dd593756ba969", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-03-12T18:02:29.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-18T19:32:41.000Z", "max_issues_repo_path": "site/en-snapshot/quantum/tutorials/qcnn.ipynb", "max_issues_repo_name": "secsilm/docs-l10n", "max_issues_repo_head_hexsha": "2acda8cb1671a826f44115e2fa6dd593756ba969", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "site/en-snapshot/quantum/tutorials/qcnn.ipynb", "max_forks_repo_name": "secsilm/docs-l10n", "max_forks_repo_head_hexsha": "2acda8cb1671a826f44115e2fa6dd593756ba969", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.1728880157, "max_line_length": 418, "alphanum_fraction": 0.5180695973, "converted": true, "num_tokens": 4879, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3849121444839335, "lm_q2_score": 0.2782567937024021, "lm_q1q2_score": 0.10710441918121508}}
{"text": "\n\nIllustration of the conditional VAE architecture. https://ijdykeman.github.io/ml/2016/12/21/cvae.html \n \n\n### Sampling\nThe sampling process is:\n\n1. Given a context $c$, sample a latent $z \\sim p(z|c)$ from the conditional prior.\n2. Decode the latent $p_\\theta(x|z, c) = D_\\theta(z, c)$.\n3. Sample a reconstruction: $x \\sim p_\\theta(x|z, c)$.\n\nIn practice we usually use simple, parametrizable distributions in the encoder and decoder. More specifically:\n\n**Encoder**\nEach latent dimension is a (univariate) gaussian, parametrized by mean and standard deviation. Note, this is the same as a multivariate guassian over the latent space with a diagional covariance matrix.\n\n**Decoder**\nWe will quantize the pixels to 0 and 1, which allows us to use a Bernoulli distribution per pixel to model it. Though for visualizations we will continue to use grayscale values.\n\n\n## The Loss\n\nWe use maximum likelihood for training, that is, ideally we would like to maximize:\n\n$$\\mathbb{E}_{x,c \\sim P^*}\\log p_{\\theta}(x|c).$$\n\nNote that $p_{\\theta}(x|c)$ is the marginal probability distribution $p_{\\theta}(x|c) = \\int p_\\theta(x, z|c) dz$. We can rewrite this in familiar terms as $\\int p_\\theta(x|z,c) p(z|c) dz$. However, computing (and maximizing) the above marginal is computationally infeasible.\n\nInstead, we can show\n\n$$\\log p_{\\theta}(x|c) \\ge \\mathbb{E}_{z \\sim q(z|x,c)} \\big[\\log p_\\theta(x | z,c)\\big] - \\mathbb{KL}\\big(q_\\phi(z | x,c) || p(z|c)\\big).$$\n\nThis right hand side is called the evidence lower bound (ELBO). Broadly speaking the term variational methods, like variational inference, refers to this technique of using an approximate posterior distribution and the ELBO; this is where Variational Autoencoder gets its name from too.\n\nIn order to try to maximize the likelihood, we maximize the ELBO instead. Recall from the lecture that under some conditions (that are not going to apply to us) the inequality is actually an equality. This yield the following loss used with Variational AutoEncoders:\n\n\n \n\nObserve that:\n* The first term encourages the model to reconstruct the input faithfully. This part is similar to the Vanilla AutoEncoder.\n* The second term can be seen as a *regularization term* of the encoder towards the prior.\n* Encoder, Decoder and Prior are conditioned on the context $c$. Removing the conditioning corresponds to recovering the original VAE formulation.\n\n(The formula contains an expectation; in practice that would be approximated with one or more samples.)\n\n## Implementation\nWe start by defining the main VAE object class.\n\nWe want to decouple its interface from how its components are defined; for example at this point we don't really care if we are using neural networks to implement the mapping from inputs to posterior.\n\nSome of the implementation will have to be `haiku` specific, but we will make an effort to restrict these details into the initialization functions. \n\n\n\n\n```\ndef _transform(component):\n return hk.without_apply_rng(hk.transform(component))\n\n# Sum-reduce on all dimensions but batch size\n_batch_sum = jax.vmap(jnp.sum) \n\n\nclass VAE():\n \"\"\"A (conditional) Variational Autoencoder.\n \n The class expects at construction time haiku modules implementing the\n conditional {encoder, decoder, prior}, as well as context projector module.\n \n The encoder, decoder and prior use the output of the context projector\n together with their other inputs to define distributions (posterior, output\n and conditional prior respectively), implemented as tfp.distributions.\n\n The context projector is used to map a potentially nested context to a single\n condition tensor.\n \"\"\"\n\n def __init__(self, *, encoder, decoder, prior, context_projector):\n self._encoder = _transform(encoder)\n self._decoder = _transform(decoder)\n self._prior = _transform(prior)\n self._context_projector = _transform(context_projector)\n\n def init_params(self, prng, data):\n prng_encoder, prng_decoder, prng_prior, prng_proj = jax.random.split(\n prng, 4)\n \n # Initialize the context mapping.\n # ADD CODE BELOW \n # -----------------------\n context_projector_params = ... \n projected_context = ...\n # -----------------------\n\n # Initialize the conditional prior.\n # ADD CODE BELOW \n # -----------------------\n prior_params = ...\n z = ...\n # -----------------------\n\n # Initialize the encoder.\n # ADD CODE BELOW \n # -----------------------\n encoder_params = ...\n # -----------------------\n\n # Initialize the decoder.\n # ADD CODE BELOW \n # -----------------------\n decoder_params = ...\n # -----------------------\n\n # Merge all the parameters into a single data structure.\n params = hk.data_structures.merge(\n context_projector_params, prior_params, encoder_params, decoder_params)\n return params\n \n def sample(self, params, prng, context, mean=True):\n prior_prng, decoder_prng = jax.random.split(prng)\n # Map the context.\n # ADD CODE BELOW \n # ----------------------- \n projected_context = ...\n # -----------------------\n\n # Get the conditional prior distribution, and take a sample from it.\n # ADD CODE BELOW \n # -----------------------\n conditional_prior = ...\n z = ...\n # -----------------------\n\n # Get the conditional output distribution.\n # ADD CODE BELOW \n # -----------------------\n output_distribution = ...\n # -----------------------\n if mean:\n return output_distribution.mean()\n else:\n return output_distribution.sample(seed=decoder_prng)\n\n def sample_prior(self, params, prng, context):\n projected_context = self._context_projector.apply(params, context)\n conditional_prior = self._prior.apply(params, projected_context)\n return conditional_prior.sample(seed=prng)\n\n def decode(self, params, prng, z, context, mean=True):\n projected_context = self._context_projector.apply(params, context)\n output_distribution = self._decoder.apply(params, z, projected_context)\n if mean:\n return output_distribution.mean()\n else:\n return output_distribution.sample(seed=prng)\n\n def reconstruct(self, params, prng, x, context, mean=True):\n posterior_prng, decoder_prng = jax.random.split(prng)\n # Map the context.\n # ADD CODE BELOW \n # ----------------------- \n projected_context = ...\n # -----------------------\n \n # Get the conditional posterior distribution p(z|x, context), and sample\n # from it.\n # ADD CODE BELOW\n # -----------------------\n posterior = ...\n z = ...\n # -----------------------\n\n # Get the conditional output distribution. \n # ADD CODE BELOW\n # -----------------------\n output_distribution = ...\n # -----------------------\n if mean:\n return output_distribution.mean()\n else:\n return output_distribution.sample(seed=decoder_prng)\n\n def stochastic_elbo(self, params, prng, x, context):\n \"\"\"ELBO = log_p(x) - KL(q(z|x) || p(z)).\"\"\"\n projected_context = self._context_projector.apply(params, context) \n z, kl = self._z_and_kl(params, prng, x, projected_context)\n output_distribution = self._decoder.apply(params, z, projected_context)\n # Sum reduce over signal domain (but not over batch!)\n log_p_x = _batch_sum(output_distribution.log_prob(x))\n elbo = log_p_x - kl\n # Assemble all the stats that we want to log in an extra output dictionary.\n extra_outputs = dict(kl=kl, log_p=log_p_x, elbo=elbo)\n return elbo, extra_outputs\n\n def kl(self, params, prng, x, context):\n projected_context = self._context_projector.apply(params, context)\n _, kl = self._z_and_kl(params, prng, x, projected_context)\n return kl\n\n def _z_and_kl(self, params, prng, x, projected_context):\n \"\"\"Sample z and compute KL(q(z|x) || p(z)) = log_p(q(z|x)) - log_p(p(x)).\"\"\"\n\n # Get the conditional prior, given the pre-projected context\n # ADD CODE BELOW\n # -----------------------\n prior = ...\n # -----------------------\n \n # Get the conditional posterior distribution p(z|x, context), and sample\n # from it. \n # ADD CODE BELOW\n # -----------------------\n posterior = ...\n z = ...\n # -----------------------\n\n # Compute the posterior log probability for the sampled z.\n # Note _batch_sum: what is this doing?\n log_q_z = _batch_sum(posterior.log_prob(z))\n \n # Compute prior log probability for the sampled z.\n # ADD CODE BELOW\n # -----------------------\n log_p_z = ...\n # -----------------------\n\n # Compute the KL (see formula)\n # ADD CODE BELOW\n # -----------------------\n kl = ...\n # -----------------------\n return z, kl\n\n```\n\nHere we define all the utilities we will need to implement Haiku modules for the prior, encoder and decoder required to instantiate a VAE.\n\n\n```\ndef _make_positive(x):\n \"\"\"Transforms elementwise unconstrained inputs into positive outputs.\"\"\"\n # The offset is such that the output will be equal to 1 whenever the input is\n # equal to 0.\n offset = jnp.log(jnp.exp(1.) - 1.)\n return jax.nn.softplus(x + offset)\n \n\nclass DiagonalNormal(tfp.distributions.Normal):\n \"\"\"Normal distribution with diagonal covariance.\"\"\"\n\n def __init__(self, params, name='diagonal_normal'):\n if params.shape[-1] != 2:\n raise ValueError(\n f'The last dimension of `params` must be 2, got {params.shape[-1]}.')\n super().__init__(\n loc=params[..., 0], scale=_make_positive(params[..., 1]), name=name)\n\n\nclass ConditionalPrior(hk.Module):\n \"\"\"A prior distribution whose parameters are computed by a conditioner.\"\"\"\n\n def __init__(self, map_ctor, distribution, name='prior_net'):\n super().__init__(name=name) \n # This function will map: (bs,) + context shape --> (bs, num_latents, 2)\n self._map = map_ctor()\n self._distribution = distribution\n\n def __call__(self, context):\n return self._distribution(self._map(context))\n\n\nclass ConditionalEncoder(hk.Module):\n \"\"\"A posterior distribution whose parameters are computed by a conditioner.\"\"\"\n\n def __init__(self, map_ctor, distribution, name='posterior_net'):\n super().__init__(name=name)\n # This function will map inputs to the to posterior distribution parameters.\n self._map = map_ctor() \n self._distribution = distribution\n\n def __call__(self, x, context): \n # We assume that x is an image and the context is flat. \n chex.assert_rank(x, 4)\n chex.assert_rank(context, 2) \n \n # Tile the context in order to be concatenated to the input tensor x.\n # ADD CODE BELOW \n # -----------------------\n bs, height, width, _ = x.shape\n context = ... \n x_and_context = ...\n # -----------------------\n\n # Compute the posterior q(z|x, context) \n return self._distribution(self._map(x_and_context))\n\n\nclass ConditionalDecoder(hk.Module):\n \"\"\"An output distribution whose parameters are computed by a conditioner.\"\"\"\n\n def __init__(self, map_ctor, distribution, name='output_net'):\n super().__init__(name=name)\n # This function will map (z, context) to the to output distribution\n # parameters.\n self._map = map_ctor()\n self._distribution = distribution\n\n def __call__(self, z, context):\n chex.assert_equal_shape_prefix([z, context], -1)\n # Concatenate the context to the latents \n # ADD CODE BELOW \n # -------------------------------------------------------------\n z_and_context = ...\n # -------------------------------------------------------------\n return self._distribution(self._map(z_and_context))\n\n\n```\n\nHere we define how to assemble the VAE.\n\n\n```\n# -- Flat model \ndef get_model(num_latents=50, num_hiddens=500, data_shape=[28, 28, 1]):\n \"\"\"Creates a fully-connected VAE model.\"\"\"\n\n def _build_map_to_latent_dist_params_net():\n return hk.Sequential([\n hk.Flatten(),\n hk.nets.MLP([num_hiddens, num_hiddens, num_latents * 2]),\n hk.Reshape([num_latents, 2]),\n ])\n\n def encoder_fn(*args, **kwargs):\n return ConditionalEncoder(\n map_ctor=_build_map_to_latent_dist_params_net,\n distribution=DiagonalNormal)(*args, **kwargs)\n \n def prior_fn(*args, **kwargs):\n return ConditionalPrior(\n map_ctor=_build_map_to_latent_dist_params_net,\n distribution=DiagonalNormal)(*args, **kwargs)\n\n def _build_map_to_output_dist_params_net():\n return hk.Sequential([\n hk.Flatten(),\n hk.nets.MLP([num_hiddens, num_hiddens, np.prod(data_shape)]),\n hk.Reshape(data_shape),\n ])\n\n def decoder_fn(*args, **kwargs):\n return ConditionalDecoder(\n map_ctor=_build_map_to_output_dist_params_net,\n distribution=tfp.distributions.Bernoulli)(*args, **kwargs) \n \n def _concatenate(tensors):\n proj = hk.nets.MLP([num_hiddens, num_latents])\n data = []\n for x in jax.tree_leaves(tensors):\n if x.ndim > 2:\n x = proj(hk.Flatten()(x))\n # Note: this is not commutative!\n # What could we do to make this projection commutative?\n data.append(x)\n data = jnp.concatenate(data, axis=-1)\n return data\n\n def proj_fn(*args):\n \"\"\"Maps context inputs to conditioning tensor.\"\"\"\n return hk.to_module(_concatenate)('context_projector')(*args)\n\n return VAE(encoder=encoder_fn,\n decoder=decoder_fn,\n prior=prior_fn,\n context_projector=proj_fn)\n\n\n```\n\n# Training\n\n## Shared hyper-parameters\n\n\n```\n# @title Shared hyper-parameters\n\n# Model hyper-parameters: you can play around with these and see what changes!\nBATCH_SIZE = 128 #@param {type:'integer'}\nVIS_BATCH_SIZE = 64 #@param {type:'integer'}\nNUM_LATENTS = 30 #@param {type:'integer'}\nNUM_HIDDENS = 50 #@param {type:'integer'}\nTRAINING_STEPS = 1000 #@param {type:'integer'}\nUSE_HARD_DATA = False #@param {type:'boolean'}\nNUM_DEV = len(jax.local_devices())\n\n# Plot configs: no need to change them \nPLOT_REFRESH_EVERY = 50 #@param {type:'integer'}\nPLOT_EVERY = 5 #@param {type:'integer'}\n```\n\n\n```\nmodel = get_model(num_latents=NUM_LATENTS, num_hiddens=NUM_HIDDENS)\n\n# Once we have trained a model, we can explore its latent space by interpolating\n# (and decoding) between latents.\ndef get_latent_interpolations(model, params, prng_key, num_steps, context):\n start_key, stop_key, decoder_key = jax.random.split(prng_key, 3)\n z_start = model.sample_prior(params, start_key, data.context)\n z_stop = model.sample_prior(params, stop_key, data.context)\n # To ensure that the interpolation is still likely under the Gaussian prior,\n # we use Gaussian interpolation - rather than linear interpolation.\n a = jnp.linspace(.0, 1.0, num_steps)\n a = jnp.expand_dims(a, axis=1)\n interpolations = (jnp.sqrt(a) * z_start + jnp.sqrt(1 - a) * z_stop)\n ncols = int(jnp.sqrt(num_steps))\n context = jax.tree_map(\n lambda x: jnp.tile(x, [num_steps] + [1] * (x.ndim-1)), data.context)\n samples_from_interpolations = model.decode(\n params, decoder_key, interpolations, context, mean=True)\n return samples_from_interpolations\n```\n\n\n```\n# These are utilities for shape manipulation to facilitate training using pmap.\n@jax.jit\ndef format_data(data):\n return jax.tree_map(\n lambda x: x.reshape((NUM_DEV, BATCH_SIZE) + x.shape[1:]), data)\n\ndef setup_for_distributed_training(params, prng_key, opt_state, num_dev):\n broadcast = lambda x: jnp.broadcast_to(x, (num_dev,) + x.shape)\n (params, opt_state) = jax.tree_map(broadcast, (params, opt_state))\n prng_key = jax.random.split(prng_key, num_dev)\n return params, prng_key, opt_state\n\nget_slice = lambda x: jax.tree_map(lambda x: x[0], x)\n\ndef reconstruct_and_sample(params, prng_key, model, data):\n prng_key = prng_key[0]\n params = get_slice(params)\n sample_key, reconstruction_key, prng = jax.random.split(prng_key, 3)\n reconstruction = model.reconstruct(\n params, reconstruction_key, data.target, data.context)\n sample = model.sample(params, sample_key, data.context)\n return data.target, reconstruction, sample\n```\n\n# Training a VAE optimizing ELBO\n\n\n```\ndef get_elbo_loss_fn(model):\n def elbo_loss_fn(params, prng, data):\n elbo, stats = jax.tree_map(\n jnp.mean, model.stochastic_elbo(params, prng, data.target, data.context)) \n return -elbo, stats\n return elbo_loss_fn\n\n```\n\n\n```\nelbo_loss_fn = get_elbo_loss_fn(model)\n\n# Initialize the model\nprng_key = jax.random.PRNGKey(0)\nparams = model.init_params(prng_key, get_dummy_data(hard=USE_HARD_DATA))\n\n# Instantiate and initialize the optimizer\nelbo_optimizer = tx.adam(1e-2)\nopt_state = elbo_optimizer.init(params)\n\n# Setup the optimizer state and params for distributed training \nparams, prng_key, opt_state = setup_for_distributed_training(\n params, prng_key, opt_state, num_dev=NUM_DEV)\n\ndataset = get_dataset(\n batch_size=BATCH_SIZE, num_dev=NUM_DEV, hard=USE_HARD_DATA)\n\n# Define and pmap the update function\ndef elbo_update(params, prng_key, opt_state, data): \n loss_key, prng_key = jax.random.split(prng_key)\n\n # Use jax.value_and_grad to compute amd return all the outputs and the\n # gradients for elbo_loss_fn (tip: what does the has_aux kwargs do?)\n # ADD CODE BELOW \n # ------------------------------------------------------------- \n loss_outputs, grads = ... \n # -------------------------------------------------------------\n\n # Reduce-mean the gradients across devices.\n # ADD CODE BELOW \n # ------------------------------------------------------------- \n grads = ...\n # ------------------------------------------------------------- \n\n # Perform an udpate step on the elbo_optimizer to produce parameter udpates,\n # them apply the updates of the model params.\n # ADD CODE BELOW \n # ------------------------------------------------------------- \n raw_updates, opt_state = ...\n params = ...\n # ------------------------------------------------------------- \n return params, prng_key, opt_state, loss_outputs\nelbo_update = jax.pmap(elbo_update, axis_name='i', devices=jax.devices())\n\n\n# -- Set up logging and interactive plotting\nlosses = []\nkls = []\nlogps = []\n\nplot = PlotLosses(\n groups={\n 'log p(x)': ['log_p'], \n 'KL': ['kl'],\n 'negative ELBO': ['negative ELBO']}, \n outputs=[MatplotlibPlot(max_cols=3, after_subplot=custom_after_subplot)],\n step_names='Iterations')\n```\n\n\n```\nfor step in range(TRAINING_STEPS): \n params, prng_key, opt_state, stats = elbo_update(\n params, prng_key, opt_state, format_data(next(dataset)))\n\n elbo = stats[1]['elbo'].mean()\n kl = stats[1]['kl'].mean()\n log_p = stats[1]['log_p'].mean()\n\n if (step + 1) % PLOT_EVERY == 0:\n plot.update({\n 'negative ELBO': -elbo,\n 'kl': kl,\n 'log_p': log_p\n }, current_step=step)\n if (step + 1) % PLOT_REFRESH_EVERY == 0:\n plot.send()\n \n losses.append(elbo)\n kls.append(kl)\n logps.append(log_p)\n```\n\n## Visualize reconstructions and samples\n\n\n\n\n\n```\ntargets, reconstructions, samples = reconstruct_and_sample(\n params, prng_key, model,\n next(get_dataset(batch_size=VIS_BATCH_SIZE, num_dev=1, hard=USE_HARD_DATA,\n data_split='test')))\n\nsz = 6\n_ = plt.figure(figsize=((3*sz, 1*sz)))\nplt.subplot(131)\nimshow(gallery(targets), 'Targets')\nplt.subplot(132)\nimshow(gallery(reconstructions), 'Reconstructions')\nplt.subplot(133)\nimshow(gallery(samples), 'Conditional samples');\n```\n\n## Explore the latent space\n\n\n\n\n```\ndata = get_dummy_data(hard=USE_HARD_DATA)\nnum_steps = 7 * 7\nsamples_from_interpolations = get_latent_interpolations(\n model, get_slice(params), jax.random.PRNGKey(1), num_steps, data.context)\n\nsz = 6\n_ = plt.figure(figsize=((2*sz, sz)))\nplt.subplot(121)\nimshow(data.target[0,...], 'Label example')\nplt.subplot(122)\nimshow(gallery(samples_from_interpolations), 'Latent space interpolation')\n```\n\n# Training a VAE with KL annealing\n\nStochastic Variational Inference can get stuck in local optima since there is a certain tension between the likelihood and the KL terms. To ease the optimization, we could use a schedule fpr $\\beta$ where the KL coefficient is slowly annealed from $0$ to $1$ throughout training. This corresponds to weight more the reconstruction term at the beginning of the training and then move towards the fully stochastic variational objective. The modified objective becomes: \n\n\n \n\nwhere the hyper-parameter $\\beta$ is annealed throughout optimization.\n\n**Tasks:**\n- Modify the training objective with a linear KL annealing schedule.\n- Look at the loss terms, what differences do you notice in their behaviours compared to the standard VAE objective?\n- Look at the reconstructions and samples during training. What do you see?\n\n\n\nFor more information, see: \n* [Bowman et al, (2015), Generating Sentences from a Continuous Space, (Section 3.1)](https://arxiv.org/abs/1511.06349)\n* [Sønderby et al, (2016), Ladder variational Autoencoder, (Section 2.3)](https://arxiv.org/abs/1602.02282)\n* [Burgess et al, (2018), Understanding disentangling in β-VAE](https://arxiv.org/abs/1804.03599)\n\n\n\n\n```\ndef get_beta_vae_loss_fn(model): \n def beta_vae_loss_fn(params, prng, beta, data):\n _, loss_components = jax.tree_map(\n jnp.mean, model.stochastic_elbo(\n params, prng, data.target, data.context))\n # The beta-VAE training loss function is a function of the beta\n # hyper-parameter. Implement the loss using the components returned by \n # the stochastic_elbo of the model class.\n # elbo_loss_fn\n # ADD CODE BELOW \n # ------------------------------------------------------------- \n loss = ... \n # ------------------------------------------------------------- \n return loss, loss_components\n return beta_vae_loss_fn\n```\n\n\n```\nprng_key = jax.random.PRNGKey(0)\nparams = model.init_params(prng_key, get_dummy_data(hard=USE_HARD_DATA))\n\nbeta_vae_loss_fn = get_beta_vae_loss_fn(model)\n\n# Set up the optimzer and model like you did for the ELBO optimization\n# ADD CODE BELOW \n# ------------------------------------------------------------- \nbeta_vae_optimizer = ... \nopt_state = ...\nparams, prng_key, opt_state = ...\ndataset = ...\n \ndef beta_vae_update(params, prng_key, opt_state, beta, data): \n ... \n return params, prng_key, opt_state, beta_vea_loss\n\nbeta_vae_update = ...\n# ------------------------------------------------------------- \n\n\n# During the optimization of the beta-VAE we will be scheduling the value of \n# beta. Use optax's polynomial schedule to set up a linear schedule, e.g.\n# from 0.01 to 1.0 over TRAINING_STEPS//2 steps.\n# ADD CODE BELOW \n# ------------------------------------------------------------- \nbeta_vae_current_step = ...\ninitial_beta, final_beta = ...\nbeta_schedule = ...\n# ------------------------------------------------------------- \n\nbeta_vae_losses = []\nbeta_vae_kls = []\nbeta_vae_logps = []\n\nbeta_vae_groups = {\n 'log p(x)': ['log_p'], \n 'kl': ['kl'],\n 'negative ELBO': ['negative ELBO'],\n 'beta': ['beta']\n}\n\nbeta_vae_plot = PlotLosses(\n groups=beta_vae_groups, \n outputs=[MatplotlibPlot(max_cols=4, after_subplot=custom_after_subplot)], \n step_names='Iterations')\n```\n\n\n```\nbroadcast = lambda x: jnp.broadcast_to(x, (NUM_DEV,) + x.shape)\n\nfor _ in range(TRAINING_STEPS):\n beta_vae_current_step += 1\n beta = beta_schedule(beta_vae_current_step)\n # Since beta is varying during training, it cannot be statically compiled into\n # udpate function and needs to be broadcast prior to being passed to the \n # beta_vae_update.\n params, prng_key, opt_state, stats = beta_vae_update(\n params, prng_key, opt_state, broadcast(beta), format_data(next(dataset)))\n \n elbo = stats[1]['elbo'].mean()\n kl = stats[1]['kl'].mean()\n log_p = stats[1]['log_p'].mean()\n\n if (beta_vae_current_step + 1) % PLOT_EVERY == 0:\n beta_vae_plot.update({\n 'negative ELBO': -elbo,\n 'kl': kl,\n 'log_p': log_p,\n 'beta': beta\n }, current_step=beta_vae_current_step)\n if beta_vae_current_step % PLOT_REFRESH_EVERY == 0:\n beta_vae_plot.send()\n \n beta_vae_losses.append(elbo)\n beta_vae_kls.append(kl)\n beta_vae_logps.append(log_p)\n```\n\n## Visualize reconstructions and samples\n\n\n```\ntargets, reconstructions, samples = reconstruct_and_sample(\n params, prng_key, model,\n next(get_dataset(batch_size=VIS_BATCH_SIZE, num_dev=1, hard=USE_HARD_DATA,\n data_split='test')))\n\nsz = 6\n_ = plt.figure(figsize=((3*sz, 1*sz)))\nplt.subplot(131)\nimshow(gallery(targets), 'Targets')\nplt.subplot(132)\nimshow(gallery(reconstructions), 'Reconstructions')\nplt.subplot(133)\nimshow(gallery(samples), 'Conditional samples');\n```\n\n## Explore the latent space\n\n\n\n```\ndata = get_dummy_data(hard=USE_HARD_DATA)\nnum_steps = 7 * 7\nsamples_from_interpolations = get_latent_interpolations(\n model, get_slice(params), jax.random.PRNGKey(1), num_steps, data.context)\n\nsz = 6\n_ = plt.figure(figsize=((2*sz, sz)))\nplt.subplot(121)\nimshow(data.target[0,...], 'Label example')\nplt.subplot(122)\nimshow(gallery(samples_from_interpolations), 'Latent space interpolation')\n```\n\n# Constrained optimization\n\nConstrained optimization can be used to dynamically tune the relative weight of the likelihood and KL terms during optimization. \nThis removes the need to manually tune $\\beta$, or create an optimization schedule, which can be problem specific.\n\nThe objective now becomes:\n\n\\begin{equation}\n \\text{minimize } \\mathbb{E}_{p^*(x)} KL(q(z|x)||p(z)) \\text{ such that } \\mathbb{E}_{p^*(x)} \\mathbb{E}_{q(z|x) \\log p_\\theta(x|z)} > \\kappa \n\\end{equation}\n\nThis can be solved using Lagrange multipliers. The objective then becomes:\n\n\\begin{equation}\n \\text{minimize } \\mathbb{E}_{p^*(x)} KL(q(z|x)||p(z)) + \\lambda (\\mathbb{E}_{p^*(x)} \\mathbb{E}_{q(z|x)} (\\kappa - \\log p_\\theta(x|z)))\n\\end{equation}\n\n\nThe difference compared to the KL annealing is that:\n\n * $\\lambda$ is a learned parameter - it will be learned using stochastic gradient descent, like the network parameters. The difference is that the lagrangian has to solve a maximization problem. You can see this intuitively: the graadient with respect to $\\lambda$ in the objective above is $\\mathbb{E}_{p^*(x)} \\mathbb{E}_{q(z|x)} (\\alpha - \\log p_\\theta(x|z))$. If $ \\mathbb{E}_{p^*(x)} \\mathbb{E}_{q(z|x)} (\\alpha - \\log p_\\theta(x|z))> 0$, the constraint is not being satisfied, so the value of the lagrangian needs to increase. This will be done by doing gradient ascent, instead of gradient descent. Note that for $\\lambda$ to be a valid lagranian in a minimization problem, it has to be positive.\n * The practicioner has to specify the hyperparameter $\\kappa$, which determines the reoncstruction quality of the model.\n * the coefficient is in front of the likelihood term, not the KL term. This is mainly for convenience, as it is easier to specify the hyperparameter $\\kappa$ for the likelihood (reconstruction loss).\n\nFor more assumptions made by this method, see the Karush–Kuhn–Tucker conditions.\n\nFor more information, see: \n * http://bayesiandeeplearning.org/2018/papers/33.pdf\n\n\n## Lagrange multipliers for constrained optimization\n\nThis is a reimplementation in JAX of the [constrained optimization tools](https://github.com/deepmind/sonnet/blob/master/sonnet/python/modules/optimization_constraints.py) found in Sonnet v1.\n\nNote the peculiar implementation of the `clip` function, which is used to limit the valid range of the multipliers; this is used for example to force their values to be non-negative, or to limit their maximum values to control the interaction of the loss components during training.\n\nIn this implementation the gradients flowing through the clipping function are not set to 0 when above and below the thresholds, if the gradients would make the inputs move towards the valid range. This is particularly useful when setting a maximum valid value, since it allows for the multipliers to become smaller once the constraints are (eventually) satisfied.\n\n\n```\n@functools.partial(jax.custom_vjp, nondiff_argnums=(1, 2, 3))\ndef clip(x, min_val, max_val, maximize=True):\n del maximize\n return jax.tree_map(lambda e: jnp.clip(e, min_val, max_val), x)\n\n\ndef clip_fwd(x, min_val, max_val, maximize):\n return clip(x, min_val, max_val, maximize), x\n\n\ndef clip_bwd(min_val, max_val, maximize, x, co_tangents):\n zeros = jax.tree_map(jnp.zeros_like, co_tangents)\n if min_val is not None:\n get_mask = lambda x, v, t: (x < v) & (t < 0 if maximize else t > 0)\n mask = jax.tree_multimap(get_mask, x, min_val, co_tangents)\n co_tangents = jax.tree_multimap(jnp.where, mask, zeros, co_tangents)\n if max_val is not None:\n get_mask = lambda x, v, t: (x > v) & (t > 0 if maximize else t < 0)\n mask = jax.tree_multimap(get_mask, x, max_val, co_tangents)\n co_tangents = jax.tree_multimap(jnp.where, mask, zeros, co_tangents)\n return co_tangents,\n\n\nclip.defvjp(clip_fwd, clip_bwd)\n\n\nclass LagrangeMultiplier(hk.Module):\n \"\"\"Lagrange Multiplier module for constrained optimization.\"\"\"\n\n def __init__(self,\n shape=(),\n initializer=1.0,\n maximize=True,\n valid_range=None,\n name='lagrange_multiplier'):\n super().__init__(name=name)\n self._shape = shape\n if callable(initializer):\n self._initializer = initializer\n else:\n self._initializer = lambda *args: jnp.ones(*args) * initializer\n self._maximize = maximize\n self._valid_range = valid_range if valid_range is not None else (0.0, None)\n assert self._valid_range[0] >= 0\n\n def __call__(self):\n lag_mul = hk.get_parameter('w', self._shape, init=self._initializer)\n lag_mul = clip(lag_mul, *self._valid_range, maximize=self._maximize)\n return lag_mul\n```\n\n## Training a VAE using GECO\n\n\n```\ndef get_geco_loss(prng, model, kappa, valid_range, init_lambda):\n\n def constraint_term(x, target): \n lag_mul = LagrangeMultiplier(\n shape=x.shape, valid_range=valid_range, initializer=init_lambda)()\n return jnp.sum(lag_mul * (x - target)), lag_mul\n constraint_term = _transform(constraint_term)\n lagmul_params = constraint_term.init(prng, jnp.ones(()), jnp.ones(()))\n\n def geco_loss(params, prng, data):\n \"\"\"Loss using constrained optimization as in GECO.\"\"\"\n # Compute the KL term (make sure to average across the batch!)\n # ADD CODE BELOW \n # -----------------------\n kl = ... \n # -----------------------\n\n # Reconstruct the inputs and compute the reconstruction error (e.g. MSE)\n # ADD CODE BELOW \n # ----------------------- \n reconstruction = ...\n reconstruction_err = ...\n # -----------------------\n\n # If you didn't use MSE before, you need to adjust the kappa term in the\n # constraint definition.\n constraint_satisfaction, lag_mul = constraint_term.apply(\n params, reconstruction_err, np.prod(data.target.shape[1:]) * kappa**2)\n loss = constraint_satisfaction + kl\n metrics = {\n 'loss': loss, \n 'mse': jnp.mean((reconstruction - data.target)**2),\n 'kl': kl,\n 'lag_mul': lag_mul}\n return loss, metrics\n\n return geco_loss, lagmul_params\n```\n\n\n```\nprng_key = jax.random.PRNGKey(0)\nkappa = 0.18\nvalid_range = (0, 4.0)\ninit_lambda = 2.0\n\nparams = model.init_params(prng_key, get_dummy_data(hard=USE_HARD_DATA))\ngeco_loss_fn, lagmul_params = get_geco_loss(\n prng_key, model, kappa, valid_range, init_lambda=init_lambda)\n```\n\n## Using multiple optimizers jointly\n\nWe will now see how we can optimize joinlty the model parameters `params` and the Lagrange multipliers `lagmul_params`.\n\nWe want to update the Lagrange multipliers via stochastic gradient *ascent*; for example we could consider using the logic in `tx.sgd` with a *negative* learning rate. The model params will be instead optimized using ADAM, just like in the previous cells.\n\nIn the next cell you will find a handy wrapper to capture multiple optimizers into a single optax object. \n\nWhat is left to do is:\n\n1. Merge all the parameters into a single tree; you can do so using the `hk.data_structures.merge` utility in Haiku:\n\n ```\n params = hk.data_structures.merge(params, lagmul_params)\n ```\n2. Specify how to filter the resulting `params` structure to select which variables should be mapped to which optimizer. Tip: you can filter the Lagrange multipliers with:\n ```\n multiplier_filter = lambda m, n, p: 'lagrange' in m\n ```\n and the model variables with:\n ```\n model_params_filter = lambda m, n, p: 'lagrange' not in m\n```\n\n\n```\ndef multi_opt(**filter_optimizer_map):\n \"\"\"Wraps multiple optimizers within an object with the optax interface.\n\n Args:\n **filter_optimizer_map: kwargs used to map optimizer names to\n (predicate, optimizer) tuples, where predicate is a function which will be\n passed to haiku.data_structure.filter in order to select which variables\n are to be updated by the corresponding optimizer.\n\n Returns:\n An optax.InitUpdate tuple.\n \"\"\"\n def filter_(predicate, params):\n if params is None:\n return None\n return hk.data_structures.filter(predicate, params)\n\n merge_ = hk.data_structures.merge\n\n def _init(params):\n opt_state = dict()\n for opt_name, (predicate, opt) in filter_optimizer_map.items():\n opt_state[opt_name] = opt.init(filter_(predicate, params))\n return opt_state\n\n def _update(updates, state, params=None):\n new_updates = {}\n new_state = dict()\n for opt_name, (predicate, opt) in filter_optimizer_map.items():\n update, new_state[opt_name] = opt.update(\n filter_(predicate, updates), state[opt_name],\n filter_(predicate, params))\n new_updates = merge_(new_updates, update)\n return new_updates, new_state\n\n return tx.InitUpdate(_init, _update)\n```\n\n\n```\n# Merge them using hk.data_structures.merge\n# function.\n# ADD CODE BELOW \n# -----------------------\nparams = ... \n# -----------------------\n\n# Optimize the Lagrange multipliers via stochastic gradient ascent.\n# Optimize the model params will be optimized using ADAM.\n# ADD CODE BELOW \n# -----------------------\ngeco_optimizer = ...\nopt_state = ...\n# -----------------------\n\nparams, prng_key, opt_state = setup_for_distributed_training(\n params, prng_key, opt_state, num_dev=NUM_DEV)\n\ndataset = get_dataset(\n batch_size=BATCH_SIZE, num_dev=NUM_DEV, hard=USE_HARD_DATA)\n\ndef geco_update(params, prng_key, opt_state, data):\n loss_key, prng_key = jax.random.split(prng_key)\n geco_loss, grads = jax.value_and_grad(\n geco_loss_fn, has_aux=True)(params, loss_key, data)\n grads = jax.lax.pmean(grads, axis_name='i')\n raw_updates, opt_state = geco_optimizer.update(grads, opt_state)\n params = tx.apply_updates(params, raw_updates)\n return params, prng_key, opt_state, geco_loss\ngeco_update = jax.pmap(geco_update, axis_name='i', devices=jax.devices())\n\ngeco_current_step = 0\nmses = []\nkls = []\nlag_muls = []\n\ngeco_groups = {\n 'mse': ['mse'],\n 'kl': ['kl'],\n 'lag_mul': ['lag_mul'],\n}\n\ngeco_plot = PlotLosses(\n groups=geco_groups,\n outputs=[MatplotlibPlot(max_cols=4, after_subplot=custom_after_subplot)], \n step_names='Iterations')\n\n```\n\n\n```\nfor _ in range(TRAINING_STEPS):\n geco_current_step += 1\n params, prng_key, opt_state, stats = geco_update(\n params, prng_key, opt_state, format_data(next(dataset)))\n mse = stats[1]['mse'].mean()\n kl = stats[1]['kl'].mean()\n lag_mul = stats[1]['lag_mul'].mean()\n\n geco_plot.update({\n 'mse': mse,\n 'kl': kl,\n 'lag_mul': lag_mul\n })\n if geco_current_step % PLOT_REFRESH_EVERY == 0:\n geco_plot.send()\n \n mses.append(mse)\n kls.append(kl) \n lag_muls.append(lag_mul)\n```\n\n## Visualize reconstructions and samples\n\n\n```\ntargets, reconstructions, samples = reconstruct_and_sample(\n params, prng_key, model,\n next(get_dataset(batch_size=VIS_BATCH_SIZE, num_dev=1, hard=USE_HARD_DATA,\n data_split='test')))\n\nsz = 6\n_ = plt.figure(figsize=((3*sz, 1*sz)))\nplt.subplot(131)\nimshow(gallery(targets), 'Targets')\nplt.subplot(132)\nimshow(gallery(reconstructions), 'Reconstructions')\nplt.subplot(133)\nimshow(gallery(samples), 'Conditional samples');\n```\n\n## Explore the latent space\n\n\n```\ndummy_data = get_dummy_data(hard=USE_HARD_DATA)\nnum_steps = 7 * 7\nsamples_from_interpolations = get_latent_interpolations(\n model, get_slice(params), jax.random.PRNGKey(0), num_steps, dummy_data.context)\n\nsz = 6\n_ = plt.figure(figsize=((2*sz, sz)))\nplt.subplot(121)\nimshow(dummy_data.target[0,...], 'Label example')\nplt.subplot(122)\nimshow(gallery(samples_from_interpolations), 'Latent space interpolation')\n```\n", "meta": {"hexsha": "2d61b02fb7391c3e4701e3c44c884b64956b4a0d", "size": 91533, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "VAE_Tutorial_Start.ipynb", "max_stars_repo_name": "linker81/tutorials2021", "max_stars_repo_head_hexsha": "f3479e7510545e4ef94aa3795683c8db7039f786", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "VAE_Tutorial_Start.ipynb", "max_issues_repo_name": "linker81/tutorials2021", "max_issues_repo_head_hexsha": "f3479e7510545e4ef94aa3795683c8db7039f786", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "VAE_Tutorial_Start.ipynb", "max_forks_repo_name": "linker81/tutorials2021", "max_forks_repo_head_hexsha": "f3479e7510545e4ef94aa3795683c8db7039f786", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.7956937799, "max_line_length": 733, "alphanum_fraction": 0.524073285, "converted": true, "num_tokens": 16007, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45713670203584295, "lm_q2_score": 0.23370635691404026, "lm_q1q2_score": 0.10683575324449598}}
{"text": "Slides of Lecture 03 and Lecture 03 of *Learning from Data*)\n- to understand the core idea (*optimization of a loss or cost function*) for parameter adjustment in machine learning\nExercise 1 \nUsing only **NumPy** (a quick introduction to this library can be found [here](http://cs231n.github.io/python-numpy-tutorial/)), complete the two functions below. Recall that $\\mathbf{X} \\in \\mathbb{R}^{N\\times d}$; thus you will need to add a component of value 1 to each of the observations in $\\mathbf{X}$ before performing the computation described above.\n\nNOTE: Although the dataset above has data of dimension $d=1$, your code must be generic (it should work for $d\\geq1$)\n\n## 1.1. Weight computation function \n\n\n```python\ndef normal_equation_weights(X, y):\n \"\"\"\n Calculates the weights of a linear function using the normal equation method.\n You should add into X a new column with 1s.\n\n :param X: design matrix\n :type X: np.ndarray(shape=(N, d))\n :param y: regression targets\n :type y: np.ndarray(shape=(N, 1))\n :return: weight vector\n :rtype: np.ndarray(shape=(d+1, 1))\n \"\"\"\n \n # START OF YOUR CODE:\n X = np.hstack(( np.ones((X.shape[0],1)), X ) )\n #print(X.T)\n Xt = np.linalg.inv(np.dot(X.T, X))\n w = np.dot(np.dot(Xt, X.T), y)\n return w\n raise NotImplementedError(\"Function normal_equation_weights() is not implemented\")\n # END OF YOUR CODE\n \n```\n\n\n```python\n# test of function normal_equation_weights()\n\nw = 0 # this is not necessary\nw = normal_equation_weights(X, y)\nprint(\"Estimated w =\\n\", w)\n```\n\n Estimated w =\n [[10804.41058626]\n [ 51.47097573]]\n\n\n## 1.2. Prediction function \n\n\n```python\ndef normal_equation_prediction(X, w):\n \"\"\"\n Calculates the prediction over a set of observations X using the linear function\n characterized by the weight vector w.\n You should add into X a new column with 1s.\n\n :param X: design matrix\n :type X: np.ndarray(shape=(N, d))\n :param w: weight vector\n :type w: np.ndarray(shape=(d+1, 1))\n :param y: regression prediction\n :type y: np.ndarray(shape=(N, 1))\n \"\"\"\n \n # START OF YOUR CODE:\n X = np.hstack(( np.ones((X.shape[0],1)), X ) )\n Y = np.dot(X, w)\n return Y\n raise NotImplementedError(\"Function normal_equation_prediction() is not implemented\")\n # END OF YOUR CODE\n\n```\n\n## 1.3. Coefficient of determination \nWe can use the [$R^2$](https://pt.wikipedia.org/wiki/R%C2%B2) metric (Coefficient of determination) to evaluate how well the linear model fits the data.\n\n**Which $𝑅^2$ value would you expect to observe ?**\n\n\n```python\nfrom sklearn.metrics import r2_score\n\n# test of function normal_equation_prediction()\nprediction = normal_equation_prediction(X, w)\n\n# compute the R2 score using the r2_score function from sklearn\n# Replace 0 with an appropriate call of the function\n\n# START OF YOUR CODE:\nr_2 = r2_score(y, prediction)\n# END OF YOUR CODE\n\nplot_points_regression(X,\n y,\n title='Real estate prices prediction',\n xlabel=\"m\\u00b2\",\n ylabel='$',\n prediction=prediction,\n legend=True,\n r_squared=r_2)\n```\n\n## Additional tests\n\nLet us compute a prediction for $x=650$\n\n\n\n```python\n# Let us use the prediction function\nx = np.asarray([650]).reshape(1,1)\nprediction = normal_equation_prediction(x, w)\nprint(\"Area = %.2f Predicted price = %.4f\" %(x[0], prediction))\n```\n\n Area = 650.00 Predicted price = 44260.5448\n\n\n## 1.4. Processing time \n\nExperiment with different nummber of samples $N$ and observe how processing time varies.\n\nBe careful not to use a too large value; it may make jupyter freeze ...\n\n\n```python\n# Add other values for N\n# START OF YOUR CODE:\nN = [1600] \n# END OF YOUR CODE\n\nfor i in N:\n X, y = get_housing_prices_data(N=i)\n init = time.time()\n w = normal_equation_weights(X, y)\n prediction = normal_equation_prediction(X,w)\n init = time.time() - init\n \n print(\"\\nExecution time = {:.8f}(s)\\n\".format(init))\n\n\n# Tempos de algumas análises:\n# N Tempo(s)\n# 100 0.00376582\n# 200 0.00273514\n# 400 0.00603080\n# 800 0.00363159\n# 1600 0.00614405\n\n```\n\n \n X shape = (1600, 1)\n y shape = (1600, 1)\n \n X: mean 645.0, sdt 320.63, max 1200.00, min 90.00\n y: mean 44313.57, sdt 16460.92, max 81999.68, min 7103.05\n \n Execution time = 0.00114775(s)\n \n\n\n# Exercise 2 \n\nLet us test the code with $𝑑>1$. \nWe will use the data we have collected in our first class. The [file](https://edisciplinas.usp.br/pluginfile.php/5982803/course/section/6115454/QT1data.csv) can be found on e-disciplinas. \n\nLet us try to predict the weight based on one or more features.\n\n\n```python\nimport pandas as pd\n\n# load the dataset\ndf = pd.read_csv('QT1data.csv')\ndf.head()\n```\n\n\n\n\n\n\n
\n \n \n Sex \n Age \n Height \n Weight \n Shoe number \n Trouser number \n \n \n \n \n 0 \n Female \n 53 \n 154 \n 59 \n 36 \n 40 \n \n \n 1 \n Male \n 23 \n 170 \n 56 \n 40 \n 38 \n \n \n 2 \n Female \n 23 \n 167 \n 63 \n 37 \n 40 \n \n \n 3 \n Male \n 21 \n 178 \n 78 \n 40 \n 40 \n \n \n 4 \n Female \n 25 \n 153 \n 58 \n 36 \n 38 \n \n \n
\n
\n\n
\n \n \n Age \n Height \n Weight \n Shoe number \n \n \n \n \n count \n 130.000000 \n 130.000000 \n 130.000000 \n 130.000000 \n \n \n mean \n 28.238462 \n 170.684615 \n 70.238462 \n 39.507692 \n \n \n std \n 12.387042 \n 11.568491 \n 15.534809 \n 2.973386 \n \n \n min \n 3.000000 \n 100.000000 \n 15.000000 \n 24.000000 \n \n \n 25% \n 21.000000 \n 164.250000 \n 60.000000 \n 38.000000 \n \n \n 50% \n 23.000000 \n 172.000000 \n 69.500000 \n 40.000000 \n \n \n 75% \n 29.000000 \n 178.000000 \n 80.000000 \n 41.000000 \n \n \n max \n 62.000000 \n 194.000000 \n 130.000000 \n 46.000000 \n \n \n
\n
2.1. One feature ($d=1$) \n\nWe will use 'Height' as the input feature and predict the weight\n\n\n```python\nfeature_cols = ['Height']\nX = df.loc[:, feature_cols]\nX.shape\n```\n\n\n\n\n (130, 1)\n\n\n\nWrite the code for computing the following\n- compute the regression weights using $\\mathbf{X}$ and $\\mathbf{y}$\n- compute the prediction\n- compute the $R^2$ value\n- plot the regression graph (use appropriate values for the parameters of function plot_points_regression() )\n\n\n```python\n# START OF YOUR CODE:\nw = normal_equation_weights(X, y)\nprediction = normal_equation_prediction(X, w)\nr_2 = r2_score(y, prediction)\nprint(\"Erro quadrático médio:\", r_2)\n\nplot_points_regression(X,\n y,\n title='Predição de peso pela altura',\n xlabel=\"altura(cm)\",\n ylabel='peso(kg)',\n prediction=prediction,\n legend=True,\n r_squared=r_2)\n\n# END OF YOUR CODE\n\n```\n\n## 2.2 - Two input features ($d=2$) \n\nNow repeat the exercise with using as input the features 'Height' and 'Shoe number'\n\n- compute the regression weights using $\\mathbf{X}$ and $\\mathbf{y}$\n- compute the prediction\n- compute and print the $R^2$ value\n\nNote that our plotting function can not be used. There is no need to do plotting here.\n\n\n```python\n# START OF YOUR CODE:\nfeature_cols = ['Height', 'Shoe number']\nX = df.loc[:, feature_cols]\nw = normal_equation_weights(X, y)\nprediction = normal_equation_prediction(X, w)\nr_2 = r2_score(y, prediction)\nprint(\"Erro quadrático médio:\", r_2)\n# END OF YOUR CODE\n\n```\n\n Erro quadrático médio: 0.45381183096658595\n\n\n## 2.3 - Three input features ($d=3$) \n\nNow try with three features. There is no need to do plotting here.\n- compute the regression weights using $\\mathbf{X}$ and $\\mathbf{y}$\n- compute the prediction\n- compute and print the $R^2$ value\n\n\n```python\n# START OF YOUR CODE:\nfeature_cols = ['Height', 'Shoe number', 'Age' ]\nX = df.loc[:, feature_cols]\nw = normal_equation_weights(X, y)\nprediction = normal_equation_prediction(X, w)\nr_2 = r2_score(y, prediction)\nprint(\"Erro quadrático médio:\", r_2)\n# END OF YOUR CODE\n\n```\n\n Erro quadrático médio: 0.4776499498669615\n\n\n## 2.4 - Your comments \n\nDid you observe anything interesting with varying values of $d$ ? Comment about it.\n\nYOUR COMMENT BELOW:\n\n===> O errro quadrático aumentou com o aumento das hispóteses. O que evidencia uma discussão desenvolvida em aula de como, mesmo com um conjunto mais diversificado de hipóteses não necessariamente o algorimto ficaria melhor, principalmente na regressão linear.\n\n\n\n", "meta": {"hexsha": "1129f84658f75a7dcc6a59f0b84efbb9081f7b21", "size": 124294, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ep02_linreg_analytic.ipynb", "max_stars_repo_name": "dslcosta1/Machine_Learning", "max_stars_repo_head_hexsha": "6d7eef5ccd061af1d96a1baf9c533ebadf097711", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "ep02_linreg_analytic.ipynb", "max_issues_repo_name": "dslcosta1/Machine_Learning", "max_issues_repo_head_hexsha": "6d7eef5ccd061af1d96a1baf9c533ebadf097711", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ep02_linreg_analytic.ipynb", "max_forks_repo_name": "dslcosta1/Machine_Learning", "max_forks_repo_head_hexsha": "6d7eef5ccd061af1d96a1baf9c533ebadf097711", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 105.2447078747, "max_line_length": 34482, "alphanum_fraction": 0.7806973788, "converted": true, "num_tokens": 6408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41111085480195975, "lm_q2_score": 0.2598256494239272, "lm_q1q2_score": 0.10681714483414503}}
{"text": "```\nimport torch, os, ipywidgets, json\nimport torch.nn as nn\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport torch.nn.functional as F\nimport torchvision as tv\nimport matplotlib.pyplot as plt\nfrom google.colab import drive\nfrom google.colab import widgets as clwidgets\nfrom tqdm import tqdm_notebook as tqdm\nfrom torchvision.datasets import MNIST\nfrom torch.utils.data import DataLoader\nPI = torch.tensor(np.pi, dtype=torch.float32)\nsns.set_style('whitegrid')\n%matplotlib inline\n```\n\n\n```\nsave_path = '/content/gdrive/My Drive/Tutorials/InfoGAN/MNIST/'\ndrive.mount('/content/gdrive', force_remount=True)\nos.makedirs(os.path.join(save_path, 'ckpt'), exist_ok=True)\n```\n\n# A quick tour on Information Maximising Generative Adversarial Networks (InfoGAN)\n*Yen Yu* $\\diamond$ *yen.yu@araya.org* $\\diamond$ *yen.yu.10@ucl.ac.uk*\n\n*17/Jun/2019*\n\n\n\n## Background\n* This Notebook traces my steps from my only knowing about GAN on a conceptual level to actually trying to learn the theory behind by implementing it. \n* I intend this Notebook to be a tutorial accessible to those who wants to learn more about geneartive modelling (there is a plan to cover other GANs and VAE+Normalising Flows).\n\n## Goal\n* The goal of this Notebook is to to provide theoretical details of GAN just enough to motivate an implementation.\n* The main focus will be on the implementation of InfoGAN\n* To successfully train an InfoGAN on the MNIST dataset.\n\n## References\n[1] The origin GAN paper by Goodfellow\n\n[2] The InfoGAN paper by Xi Chen\n\n[3] Ferenc Huszar's [blog post](https://www.inference.vc/infogan-variational-bound-on-mutual-information-twice/)—very insightful\n\n[4] [Useful GAN hacks (multiple authors)](https://github.com/soumith/ganhacks#authors)\n\n## Classic GAN\n### Theory\n#### Layperson example\n\nYou are visiting a friend who is working in the packaging department of a factory. His/her job is to load the products onto a conveyer belt to initiate automatic packaging. You noticed, from the control room, that the conveyer belt has a layout resembling the shape of the letter Y. Products are loaded onto the branches on the top end and get merged into a single line at the junction in the middle. The packaging mechnism is located at the bottom end. An electronic gate at the junction controls which branch gets to pass. Whenever the indicator light on the gate shines red the left branch feeds into the bottom branch. And when a green light is shone, the opposite is the case.\n\nYou know the factory has a long-term partnership with a particular supplier who provides the standard products for this line. When the supply is short, the factory seeks additional supply from another supplier but thier quality can be a hit and miss.\n\nToday, both branches are operating but you have no idea whether there has been a supply shortage. If there is a shortage, one of the branches must be carrying products of \"somewhat questionable quality\".\n\nFrom the control room terminal, you see the gate camera view, along with its indicator light. Out of curiosity, you decide to challenge yourself to answer whether there *is* a shortage by finding out whether different lights signal a discernable impression on the product quality.\n\nThis time, you are positive because the non-standard products have a grey-ish tint.\n\nHopefully, on your next visit, knowing that there is still a shortage going on, you will find yourself having a hard time arriving at a definite conclusion. This can almost mean the additional supplier has boosted their quality to be on a par with the standard.\n\n#### Remarks\n\n* A Generative Adversarial Network (GAN) typically consists of a generator and a discriminator, both as trainable neural networks. The generator tries to generate samples to fool the discriminator, making it believe the generated samples are as good as the real ones. And the discriminator tries to unfool itself.\n* The standard supplier provides the *real* data: $x_{real}$.\n* The second supplier, which is the generator, provides the *fake* data: $x_{fake}$\n* You, the discriminator, serve to differentiate the real from the fake. But you also help the fake fake better.\n* The role of the indicator light $d$ will become clear in the following part.\n* The layperson example lends itself to an information-theoretical interpretation as described below.\n\n#### An information-theoretic perspective\n\nLet us consider two random variables $x_{real}$ and $x_{fake}$, one representing data coming from a *real* distribution and another trying to mimic it. And $d \\sim \\mathrm{Bern}(0.5)$ being a mixing factor allows the following interaction: \n\n$$\n\\begin{align} \nx &= \\left\\{ \n \\begin{array}{l}\n x_{real},\\; \\hbox{ if } d=1 \\\\\n x_{fake},\\; \\hbox{ if } d = 0\n \\end{array}\n \\right.\n\\end{align}\n$$\n\nThe task for a classic GAN is to make $x_{fake}$ as real as possible such that knowing $d$ provides minimal, if not none, insights into the actual identity of $x$. In the language of information theory, this is equivalent to saying\n\n$$\\min I(x : d)$$\n\nThe learning rule of the classic GAN can be derived from here by considering:\n\n$$\n\\begin{align}\nI(x : d) &= H(d) - H(d | x) \\\\\n &= H(d) + \\mathbb E_x \\mathbb E_{d|x} \\log p(d|x) \\\\\n &= H(d) + \\mathbb E_{d,x} \\frac {\\log p(d|x)} {\\log q(d|x)} \\log q(d|x) \\\\\n &\\ge H(d) + \\mathbb E_{d,x} \\log q(d|x)\n\\end{align}\n$$\n\nHere, an auxiliary density $q_{d|x}$ is introduced to create a lower bound on the mutual information. This bound is tight when $p(d|x) = q(d|x)$. Then the following holds:\n\n$$\n\\begin{align}\nI(x:d) &= H(d) + \\max_{q_{d|x}} \\mathbb E_{d,x} \\log q(d|x) \\\\\n &\\ge H(d) + \\max_\\varphi \\mathbb E_{d,x} \\log q(d|x; \\varphi)\n\\end{align}\n$$\n\nwhere the last line turns $q_{d|x}$ into a parametric family by assumption.\n\nThen, one can expand the expectation to rewrite the expression since we knew $q$ is a coin-flip:\n\n$$\n\\begin{align}\nI(x:d) &\\ge H(d) + \\max_\\varphi \\left( \n \\mathbb E_{x_{real}} \\log q(1 | x_{real};\\varphi) +\n \\mathbb E_{x_{fake}} \\log q(0 | x_{fake}; \\varphi)\n \\right)\n\\end{align}\n$$\n\n\n\n### Implementation\nFollowing the derivation immediately above, it becomes clear that we can treat the approximate density $q(d=\\{0, 1\\} | x; \\varphi)$ as a deep neural network that works as a discriminator ($\\mathcal D(x; \\varphi)$) . Specifically, we want this D network to take as input, say, an image tensor and output a scalar between 0 and 1. This D network should be able to tell $x$ apart by learning to assign 1 to $x_{real}$ and 0 to $x_{fake}$:\n$$\n\\begin{align}\n&= H(d) + \\max_\\varphi \\left( \n \\mathbb E_{x_{real}} \\log \\mathcal D(x_{real};\\varphi) + \n \\mathbb E_{x_{fake}} \\log [1 - \\mathcal D(x_{fake}; \\varphi)]\n \\right) \n\\end{align}\n$$\nOn the other hand, $x_{fake}$ is something we have to create from nothing (well, from noise, to be exact). And we can assign this task to another neural network that we'd like to call the generator $\\mathcal G(z; \\vartheta)$, where $z$ is the noise vector. By replaceing $x_{fake}$ with $\\mathcal D(z; \\vartheta)$ we sidestep the need to actually evaluate the expectation $\\mathbb E_{x_{fake}}$. Instead, we are now dealing with a much simpler $\\mathbb E_z$, whcih can be Monte Carlo approximated:\n\n$$\n\\begin{align}\n&=H(d) + \\max_\\varphi \\left( \n \\mathbb E_{x_{real}} \\log \\mathcal D(x_{real};\\varphi) + \n \\mathbb E_{z} \\log [1 - \\mathcal D(\\mathcal G(z; \\vartheta); \\varphi)]\n \\right)\n\\end{align}\n$$\n\nwhere $\\vartheta$ parametrises the generator network $\\mathcal G$ and $z \\sim N(0,1)$ is some Gaussian noise conventionally used by GAN.\n\nThe G network has to learn to fool the D network as the D network tries to tell the real and fake apart. This brings us back to our initial objective of minimising the mutual information. We can now write down the classic GAN objective:\n\n$$\n\\begin{align}\n\\min_\\vartheta \\max_\\varphi \\left( \n \\mathbb E_{x_{real}} \\log \\mathcal D(x_{real};\\varphi) + \n \\mathbb E_{z} \\log [1 - \\mathcal D(\\mathcal G(z; \\vartheta); \\varphi)]\n \\right)\n\\end{align}\n$$\n\n\n#### Task\nTo implement a classic GAN, we need to program the following:\n* A discriminator network $\\mathcal D$ that maps an input to a real number between 0 and 1 (as representing probability)\n* A generator $\\mathcal G$ that takes some noise vector of arbitrary dimension \n* Write down the objective function\n\n\n```\n%%script false\n# This is only a demonstration cell\n\n# Taks 1: Program a discriminator network\nclass Discriminator(nn.Module):\n \"\"\"A Discriminator network represents a function \n that maps an input to a scalar between (0, 1).\"\"\"\n def __init__(self):\n super(Discriminator, self).__init__()\n \n # The following contains the main component of the\n # desired function. It can take any valid architecture.\n # But for the sake of demonstration, I will only include \n # minimal numbers of network layers, assuming the inputs\n # are mini-batches of MNIST images which are monochromatic,\n # 28x28 images.\n self.layers = nn.Sequential(\n # NB. setting bias=False only because BN is used. The beta parameter\n # in a BN works just like a bias.\n nn.Conv2d(1, 64, (3, 3), stride=(2, 2), padding=1, bias=False),\n nn.BatchNorm2d(64),\n nn.LeakyReLU(0.1),\n nn.Conv2d(64, 128, (3, 3), stride=(2, 2), padding=1, bias=False),\n nn.BatchNorm2d(128),\n nn.LeakyReLU(0.1),\n nn.Conv2d(128, 1024, (7, 7), stride=(1, 1), padding=0, bias=False),\n nn.BatchNorm2d(1024)\n nn.LeakyReLU(0.1),\n nn.Conv2d(1024, 1, (1, 1), stride=(1, 1), padding=0, bias=True),\n nn.Sigmoid()\n )\n \n def forward(self, x):\n return self.layers(x)\n\n# Task 2: Program a generator network\nclass Generator(nn.Module):\n \"\"\"A Generator is a function that maps a latent code (usually a noise vector) of\n arbitrary dimension (here 74 is used) to a tensor that mimics real dataset.\"\"\"\n def __init__(self):\n super(Generator, self).__init__()\n \n self.layers = nn.Sequential(\n nn.Conv2d(74, 1024, (1, 1), (1, 1), bias=False, padding=0),\n nn.LeakyReLU(0.1),\n nn.BatchNorm2d(1024),\n nn.ConvTranspose2d(1024, 128, (7, 7), (1, 1), bias=False, padding=0),\n nn.BatchNorm2d(128),\n nn.LeakyReLU(0.1),\n nn.ConvTranspose2d(128, 64, (4, 4), (2, 2), bias=False, padding=1),\n nn.BatchNorm2d(64),\n nn.ConvTranspose2d(64, 1, (4, 4), (2, 2), bias=True, padding=1),\n nn.Sigmoid())\n\n self.apply(initialise_weights)\n \n def forward(self, x):\n return self.layers(x)\n\n# Task 3: Write down the GAN loss\nclass ClassicGANCriterion:\n def __call__(self, prob, label):\n prob = prob.view(-1)\n label = torch.zeros_like(prob).fill_(label)\n return F.binary_cross_entropy(prob, label)\n```\n\n## InfoGAN\n\n\nThe classic GAN generator places no restrictions on how the noise vector should be used to generate data. It can inadvertently come to ignore a big part of that noise vector by essentially map a range of value to the same output. As a result, the generator will fail to capture the true data distribution and quite often end up with one with very low entropy. Naturally, a generator behaviing like this will do a very poor job in fooling the discriminator. This failure mode is marked by high generator loss and 0 discriminator loss, otherwise known as \"mode collapse\" of GAN.\n\nThe authors of InfoGAN attempted to prevent mode collapse by introducing one regulariser as restriction. This restriction is such that any generator output, give a noise vector, has to retain maximum information about that vector. This is the same as saying:\n\n$$\n\\max I(z, x_{fake})\n$$\n\nInfoGAN does this by allowing a partition in the noise vector. In classic GAN, a noise vector can be as simple as $z \\sim N(\\boldsymbol{0}, Id)$, where $\\boldsymbol{0}$ is a zero vector and $Id$ is an identity matrix of arbitrary dimension. InfoGAN chooses to have $z = \\{ c, z'\\}$, where $c$ is a noise vector from a known distribution whose sufficient statistics must be recovered after the generation process (in the form of posterior estimates, but more on that later!). Whereas, $z'$ is the same old noise vector ($z$) used by classic GAN, meaning there will be no restrictions placed on $z'$.\n\nWe can then rewrite the mutual information above to only include $c$, i.e., $I(c, x_{fake})$. For InforGAN, the following is to be minimised\n\n$$\nI(d, x) - \\lambda I(c, x_{fake})\n$$\nwhere $\\lambda$ serves to adjust scale (entropy and mutual information are not scale-invariant).\n\n### Implementation\nTo see how this can be implemented using neural network, we trace our steps in the previous section and attempt a similar work on the newly introduced regulariser. We have\n\n$$\n\\begin{align}\nI(c, x_{fake}) &= H(c) - H(c | x_{fake}) \\\\\n&= H(c) + \\mathbb E_{z\\sim p(z)} \\mathbb E_{c \\sim p(c)} \\log p(c | x_{fake}) \\\\\n&= H(c) + \\mathbb E_{z, c} \\log p(c | \\mathcal G(c, z)) \n\\end{align}\n$$\n\nIf we create a variational lower bound just like we did earlier we would have a difficult time evaluating the log-probability in the second term. However, by Law of Total Expectation, we can now see this expression in a different light:\n\n$$\n\\begin{align}\n\\mathbb E_{z, c} \\log p(c |\\mathcal G(c, z)) &= \n \\mathbb E_{z, c} \\mathbb E_{c' \\sim p(c'|x_{fake})} \\log p(c' | \\mathcal G (c, z)) \\\\\n&= \\mathbb E_{z, c} \\mathbb E_{c' \\sim p(c'|x_{fake})} \\log \\frac {p(c'|x_{fake})}{q(c'|x_{fake})} q(c'|x_{fake}) \\\\\n&\\ge \\mathbb E_{z, c} \\mathbb E_{c' \\sim p(c'|x)} \\log q(c'|x_{fake})\n\\end{align}\n$$\n\nThis means we will use $c$ and $z$ to get our $x_{fake}$ through the generator $\\mathcal G$. Then program a neural network as $q(c'|x_{fake})$—assuming a known family of probability distributions—that takes as input $x_{fake}$ and outputs the sufficient statistics of the approximate density $q_{c'|x_{fake}}$ (which is called a Recognition Model in the paper). There! We can work out the log-probability with much less effort.\n\n#### Generator and utility objects\nFirst, let us take care of the usual generator and we will get to the discriminator and recognition model after that. We have done this bit in the classic GAN section and there is nothing new in particular, only we have introduced a different normalisation module (which I might want to compare aginst BatchNorm later).\n\n\n```\ndef initialise_weights(module):\n if isinstance(module, nn.Conv2d) or isinstance(module, nn.ConvTranspose2d):\n nn.init.xavier_normal_(module.weight.data)\n if isinstance(module.bias, torch.Tensor):\n module.bias.data.fill_(0.)\n\n\nclass GroupNorm2d(nn.Module):\n \"\"\"Group Normalisation Layer.\"\"\"\n def __init__(self, channels, groups, eps=1e-5):\n super(GroupNorm2d, self).__init__()\n \n self.gamma = nn.Parameter(torch.ones(1, channels, 1, 1))\n self.beta = nn.Parameter(torch.zeros(1, channels, 1, 1))\n self.num_groups = groups\n self.eps = eps\n\n def forward(self, x):\n N, C, H, W = x.size()\n G = self.num_groups\n\n x = x.view(N, G, -1)\n mean = x.mean(dim=2, keepdim=True)\n var = (x - mean).pow(2).sum(2, keepdim=True) / x.size(2)\n\n x = (x - mean) / (var + self.eps).sqrt()\n x = x.view(N, C, H, W)\n\n return x * self.gamma + self.beta\n\n\nclass Generator(nn.Module):\n \"\"\"The Generator Network.\"\"\"\n def __init__(self):\n super(Generator, self).__init__()\n # Network architecture follows the original InfoGAN paper (Chen et al.)\n self.layer = nn.Sequential(\n nn.Conv2d(74, 1024, (1, 1), (1, 1), bias=False, padding=0),\n nn.LeakyReLU(0.1),\n GroupNorm2d(1024, 32),\n nn.ConvTranspose2d(1024, 128, (7, 7), (1, 1), bias=False, padding=0),\n GroupNorm2d(128, 32),\n nn.LeakyReLU(0.1),\n nn.ConvTranspose2d(128, 64, (4, 4), (2, 2), bias=False, padding=1),\n GroupNorm2d(64, 32),\n nn.ConvTranspose2d(64, 1, (4, 4), (2, 2), bias=True, padding=1),\n nn.Tanh())\n\n self.apply(initialise_weights)\n \n def sample_latent(self, batch_size, device):\n # all dimension information is mentioned in the original InfoGAN paper\n # incompressible noise (z)\n z = torch.randn(batch_size, 62, device=device)\n\n # categorical latent code (cd)\n # c ~ Categ(K=10, p=0.1)\n index = torch.randint(0, 10, (batch_size,), device=device)\n cd = torch.zeros(batch_size, 10, device=device)\n cd[torch.arange(batch_size), index] = 1\n\n # continuous latent codes (cc)\n # c ~ Unif(-1., 1.)\n cc = torch.rand((batch_size, 2), device=device) * 2. - 1.\n\n noise = torch.cat([z, cd, cc], dim=1).view(-1, 74, 1, 1)\n return noise, index\n \n def forward(self, x):\n return self.layer(x)\n```\n\n#### Discriminator and Recognition model\nHere, we have split the discriminator network into two parts (the \"SharedNetwork\" and \"DiscriminatorEnd\") and have one part shared with the Recognition model. This can be interpreted as using the Recognition model (which works as inferring the sufficient statistics of the seed noise vector) as an auxiliary task for the discriminator network. Auxiliary task tends to help obtain good representation. The same technique is also seen in reinforcement learning. We also attached another network to the discriminator to classify images from the true dataset which seems to help stablise training.\n\n\n```\nclass SharedNetwork(nn.Module):\n \"\"\"Network shared between the Discriminator and Recognition model.\"\"\"\n def __init__(self):\n super(SharedNetwork, self).__init__()\n \n # Average pooling is used here in place of the usual max pooling or strides\n # Empirically, this avoids sparse gradients and tends to prevent mode collapse.\n self.net_base = nn.Sequential(\n nn.Conv2d(1, 64, (4, 4), (1, 1), bias=False, padding=0),\n nn.LeakyReLU(0.1),\n nn.AvgPool2d((2, 2)),\n GroupNorm2d(64, 32),\n nn.Conv2d(64, 128, (4, 4), (1, 1), bias=False, padding=0),\n nn.LeakyReLU(0.1),\n nn.AvgPool2d((2, 2)),\n GroupNorm2d(128, 32),\n nn.Conv2d(128, 1024, (4, 4), (1, 1), bias=False, padding=0),\n nn.LeakyReLU(0.1),\n GroupNorm2d(1024, 32))\n \n self.apply(initialise_weights)\n \n def forward(self, x):\n x = self.net_base(x)\n return x\n\n\nclass DiscriminatorEnd(nn.Module):\n \"\"\"The Discriminator.\"\"\"\n def __init__(self):\n \n super(DiscriminatorEnd, self).__init__()\n \n self.net_d = nn.Sequential(\n nn.Conv2d(1024, 1, (1, 1), (1, 1), bias=True, padding=0),\n nn.Sigmoid())\n\n self.apply(initialise_weights)\n\n def forward(self, x):\n return self.net_d(x).squeeze(3).squeeze(2)\n\n\nclass RecognitionEnd(nn.Module):\n \"\"\"The Recognition model.\"\"\"\n def __init__(self):\n super(RecognitionEnd, self).__init__()\n \n self.net_r = nn.Sequential(\n nn.Conv2d(1024, 128, (1, 1), (1, 1), bias=True, padding=0),\n nn.LeakyReLU(0.1),\n GroupNorm2d(128, 32))\n \n self.cat_r = nn.Conv2d(128, 10, (1, 1), (1, 1), bias=True, padding=0)\n self.gau_r = nn.Conv2d(128, 4, (1, 1), (1, 1), bias=True, padding=0)\n \n self.apply(initialise_weights)\n \n def forward(self, x):\n r = self.net_r(x)\n cat = self.cat_r(r).squeeze(3).squeeze(2)\n gau = self.gau_r(r).squeeze(3).squeeze(2)\n mean, logv = torch.chunk(gau, 2, dim=1)\n return cat, mean, logv\n\n \nclass ClassifierEnd(nn.Module):\n \"\"\"Auxiliary Classification for the D Network.\"\"\"\n # Introducing an auxiliary task whenever possible tends to help stabalise training.\n def __init__(self):\n super(ClassifierEnd, self).__init__()\n self.net_c = nn.Sequential(\n nn.Conv2d(1024, 10, (1, 1), (1, 1), bias=True, padding=0))\n \n def forward(self, x):\n logits = self.net_c(x).view(-1, 10)\n return F.softmax(logits, dim=1)\n```\n\n## Training InfoGAN to generate MNIST digits\n### Loss functions\n\n\n```\nclass NaNError(Exception):\n pass\n\n\nclass CriterionDiscriminator:\n \"\"\"Binary Cross Entropy Loss.\"\"\"\n def __call__(self, prob, label):\n prob = prob.view(-1)\n label = torch.zeros_like(prob).fill_(label)\n return F.binary_cross_entropy(prob, label)\n \n \nclass CriterionRecognitionCategorial:\n \"\"\"Categorial Cross Entropy Loss\"\"\"\n def __call__(self, logits, index):\n return F.cross_entropy(logits, index)\n\n\nclass CriterionRecognitionNLL:\n \"\"\"Negative log-likelihood for factorised Normal distribution.\"\"\"\n def __call__(self, sample, mean, logv):\n sample = sample.squeeze()\n scale = (0.5 * logv).exp()\n normal = torch.distributions.Normal(mean, scale)\n # variance = logv.exp()\n # nll = (0.5 * torch.log(2 * PI).add(logv) + \n # (sample - mean).pow(2).div(2 * variance + 1e-5))\n\n return - normal.log_prob(sample).sum(dim=1).mean()\n```\n\n### Setting up training\n- Download the MNIST dataset and prepare data sampler\n- Create new instances of network\n- Define optimisers (for G and D networks, respectively)\n\n\n```\n%%capture\n# Download the MNIST dataset\ntransforms = tv.transforms.Compose([\n tv.transforms.ToTensor(),\n tv.transforms.Normalize((0.5,), (0.5,))\n])\nmnist_data = {\n 'train': MNIST('.', train=True, transform=transforms, download=True),\n 'test': MNIST('.', train=False, transform=transforms, download=True)}\n```\n\n\n```\n# Training settings and save names\ncheckpoint = 0\nsettings = {\n 'batch_size': 128,\n 'num_epochs': 300,\n 'lr_g': 2e-4,\n 'lr_d': 2e-4,\n 'beta1': 0.5,\n 'beta2': 0.999,\n 'save_every': 50,\n 'trained_d': 'trained_d.pth',\n 'trained_g': 'trained_g.pth',\n 'trained_r': 'trained_r.pth',\n 'trained_c': 'trained_c.pth',\n 'trained_shared': 'trained_shared.pth',\n 'training_log': 'training_log.csv'}\n\n# Pytorch DataLoader\ndata_loader = {\n 'train': DataLoader(mnist_data['train'], batch_size=settings['batch_size'], shuffle=True, drop_last=True),\n 'test': DataLoader(mnist_data['test'], batch_size=settings['batch_size'], shuffle=True, drop_last=True)}\n\n# --- Create networks:\n# One can potentially introduce an auxiliary classifier network as part of the D network.\n# An auxiliary task, empirically, tends to help the stability of GAN training.\nnets = {'G': Generator().cuda(), 'D': DiscriminatorEnd().cuda(), 'R': RecognitionEnd().cuda(), \n 'Shared': SharedNetwork().cuda(), 'C': ClassifierEnd().cuda()}\n\n# --- Optimisers:\n# ADAM was chosen for G network and its hyperparameters (betas) follow that of DC-GAN\n# SGD may be chosen for D network (empirically, this prevents discriminator mode collapse, i.e., D loss becomes zero)\noptimiser = {\n 'G': torch.optim.Adam([{'params': nets['G'].parameters()}, \n {'params': nets['R'].parameters()}], \n lr=settings['lr_g'],\n betas=[settings['beta1'], settings['beta2']]),\n 'D': torch.optim.SGD([{'params': nets['D'].parameters()}, \n {'params': nets['C'].parameters()},\n {'params': nets['Shared'].parameters()}], \n lr=settings['lr_d'])}\n\n# --- Loss functions:\n# For D network, use binary cross entropy\n# For Recognition (R) network, use categorical cross entropy for discrete latent codes;\n# use negative Gaussian log-likelihood for continuous latent codes.\ncrit_d = CriterionDiscriminator()\ncrit_r_ce = CriterionRecognitionCategorial()\ncrit_r_nll = CriterionRecognitionNLL()\n\n# Save the settings for later reference.\nwith open(os.path.join(save_path, 'notebook_settings.json'), 'w') as file:\n json.dump(settings, file, sort_keys=True)\n```\n\n\n```\n%%script false # Comment out this line to enable this cell\n\n# Recover from previous checkpoint \ncheckpoint = 250\nckpt_path = os.path.join(save_path, 'ckpt')\nnets['D'].load_state_dict(torch.load(os.path.join(ckpt_path, 'ckpt_d_{:03d}.pth'.format(checkpoint-1))))\nnets['G'].load_state_dict(torch.load(os.path.join(ckpt_path, 'ckpt_g_{:03d}.pth'.format(checkpoint-1))))\nnets['R'].load_state_dict(torch.load(os.path.join(ckpt_path, 'ckpt_r_{:03d}.pth'.format(checkpoint-1))))\nnets['C'].load_state_dict(torch.load(os.path.join(ckpt_path, 'ckpt_c_{:03d}.pth'.format(checkpoint-1))))\nnets['Shared'].load_state_dict(torch.load(os.path.join(ckpt_path, 'ckpt_shared_{:03d}.pth'.format(checkpoint-1))))\ntraining_log = pd.read_csv(os.path.join(ckpt_path, 'ckpt_training_log_{:03d}.csv').format(checkpoint-1))\nprint('Recovered checkpoint: {}'.format(checkpoint))\n```\n\n### Main training script\n\n\n\n```\n%%script false\n\ntraining_log = pd.DataFrame(columns=['epoch', 'phase', 'd_loss', 'g_loss', 'r_loss_cat', 'r_loss_gaus', 'c_loss'])\npgrid = clwidgets.Grid(1, 6)\n\n# Main training script\nfor epoch in tqdm(range(checkpoint, settings['num_epochs'])):\n for phase in ['train']:\n for img_real, label in data_loader[phase]:\n i = len(training_log)\n img_real = img_real.to('cuda')\n label = label.to('cuda')\n noise, cat_index = nets['G'].sample_latent(settings['batch_size'], 'cuda')\n \n # Improve the Discriminator\n with torch.set_grad_enabled(phase == 'train'):\n optimiser['D'].zero_grad()\n shared_real = nets['Shared'](img_real)\n pr_real = nets['D'](shared_real)\n pr_auxc = nets['C'](shared_real)\n img_fake = nets['G'](noise)\n pr_fake = nets['D'](nets['Shared'](img_fake.detach()))\n\n loss_d = crit_d(pr_real, 1) + crit_d(pr_fake, 0)\n loss_c = F.cross_entropy(pr_auxc, label)\n \n if phase == 'train':\n (loss_d + loss_c).backward()\n optimiser['D'].step()\n \n # Improve the Generator and Recognition model\n if phase == 'train':\n optimiser['G'].zero_grad()\n shared_fake = nets['Shared'](img_fake)\n pr_fake = nets['D'](shared_fake)\n r_logit, r_mean, r_logv = nets['R'](shared_fake)\n\n loss_g = crit_d(pr_fake, 1) \n loss_cat = crit_r_ce(r_logit, cat_index) \n loss_gaus = crit_r_nll(noise[:, -2:], r_mean, r_logv)\n \n (loss_g + loss_cat + 0.1 * loss_gaus).backward()\n optimiser['G'].step()\n \n training_log.loc[i] = [epoch, phase, loss_d.item(), loss_g.item(), loss_cat.item(), loss_gaus.item(), loss_c.item()]\n \n # some sanity check for training\n if training_log.loc[i].isnull().any():\n raise NaNError\n else:\n # if not in training phase, treat g-losses as missing\n training_log.loc[i] = [epoch, phase, loss_d.item(), np.nan, np.nan, np.nan, loss_c.item()]\n \n # keep a training checkpoint\n if (epoch + 1) % settings['save_every'] == 0:\n torch.save(nets['D'].state_dict(), os.path.join(save_path, 'ckpt', 'ckpt_d_{:03d}.pth'.format(epoch)))\n torch.save(nets['G'].state_dict(), os.path.join(save_path, 'ckpt', 'ckpt_g_{:03d}.pth'.format(epoch)))\n torch.save(nets['R'].state_dict(), os.path.join(save_path, 'ckpt', 'ckpt_r_{:03d}.pth'.format(epoch)))\n torch.save(nets['C'].state_dict(), os.path.join(save_path, 'ckpt', 'ckpt_c_{:03d}.pth'.format(epoch)))\n torch.save(nets['Shared'].state_dict(), os.path.join(save_path, 'ckpt', 'ckpt_shared_{:03d}.pth'.format(epoch)))\n training_log.to_csv(os.path.join(save_path, 'ckpt', 'ckpt_training_log_{:03d}.csv'.format(epoch)))\n \n # plot progress at the end of each epoch\n with pgrid.output_to(0, 0):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n plt.imshow(img_real[0, 0].detach().cpu().numpy())\n plt.gca().set_title('Real Example ({})'.format(epoch))\n plt.gca().grid(False)\n plt.gca().set_axis_off()\n with pgrid.output_to(0, 1):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n plt.imshow(img_fake[0, 0].detach().cpu().numpy())\n plt.gca().set_title('Fake Example ({})'.format(epoch))\n plt.gca().grid(False)\n plt.gca().set_axis_off()\n with pgrid.output_to(0, 2):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='d_loss', data=training_log.tail(20000))\n with pgrid.output_to(0, 3):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='g_loss', data=training_log.tail(20000))\n with pgrid.output_to(0, 4):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='r_loss_cat', data=training_log.tail(20000))\n with pgrid.output_to(0, 5):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='r_loss_gaus', data=training_log.tail(20000))\n\n# save model and training log for later use\ntorch.save(nets['D'].state_dict(), os.path.join(save_path, settings['trained_d']))\ntorch.save(nets['G'].state_dict(), os.path.join(save_path, settings['trained_g']))\ntorch.save(nets['R'].state_dict(), os.path.join(save_path, settings['trained_r']))\ntorch.save(nets['C'].state_dict(), os.path.join(save_path, settings['trained_c']))\ntorch.save(nets['Shared'].state_dict(), os.path.join(save_path, settings['trained_shared']))\ntraining_log.to_csv(os.path.join(save_path, settings['training_log']))\n```\n\n\n```\n# %%script false\n# load trained model \nwith open(os.path.join(save_path, 'notebook_settings.json'), 'r') as file:\n settings = json.load(file)\n\nnets['D'].load_state_dict(torch.load(os.path.join(save_path, settings['trained_d'])))\nnets['G'].load_state_dict(torch.load(os.path.join(save_path, settings['trained_g'])))\nnets['R'].load_state_dict(torch.load(os.path.join(save_path, settings['trained_r'])))\nnets['C'].load_state_dict(torch.load(os.path.join(save_path, settings['trained_c'])))\nnets['Shared'].load_state_dict(torch.load(os.path.join(save_path, settings['trained_shared'])))\ntraining_log = pd.read_csv(os.path.join(save_path, settings['training_log']))\n\n# Download the MNIST dataset\ntransforms = tv.transforms.Compose([\n tv.transforms.ToTensor(),\n tv.transforms.Normalize((0.5,), (0.5,))\n])\nmnist_data = {\n 'train': MNIST('.', train=True, transform=transforms, download=True),\n 'test': MNIST('.', train=False, transform=transforms, download=True)}\n```\n\n\n```\nnoise, _ = nets['G'].sample_latent(1, 'cuda')\nimg_fake = nets['G'](noise)\nimg_real = mnist_data['test'][0][0].view(1, 1, 28, 28)\npgrid = clwidgets.Grid(1, 6)\nwith pgrid.output_to(0, 0):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n plt.imshow(img_real[0, 0].detach().cpu().numpy())\n plt.gca().set_title('Real Example')\n plt.gca().grid(False)\n plt.gca().set_axis_off()\nwith pgrid.output_to(0, 1):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n plt.imshow(img_fake[0, 0].detach().cpu().numpy())\n plt.gca().set_title('Generated Example')\n plt.gca().grid(False)\n plt.gca().set_axis_off()\nwith pgrid.output_to(0, 2):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='d_loss', data=training_log)\nwith pgrid.output_to(0, 3):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='g_loss', data=training_log)\nwith pgrid.output_to(0, 4):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='r_loss_cat', data=training_log)\nwith pgrid.output_to(0, 5):\n pgrid.clear_cell()\n plt.figure(figsize=(3, 3))\n sns.lineplot(x='epoch', y='r_loss_gaus', data=training_log)\n```\n\n###Plot a number of random samples\nBelow shows 100 images, arranged into a 10x10 grid, generated by the GAN we just trained. \n\n\n\n```\nz = torch.randn(100, 62, 1, 1, device='cuda')\nk = torch.zeros(100, 10, 1, 1, device='cuda')\nk[torch.arange(100), torch.randint(0, 10, (100,))] = 1.\nc = torch.stack(torch.meshgrid(torch.linspace(-1, 1, 10), torch.linspace(-1, 1, 10)), dim=2).view(100, 2, 1, 1).cuda()\n\nwith torch.no_grad():\n latc = torch.cat([z, k, c], dim=1)\n img_fake = nets['G'](latc)\n img_fake = img_fake.view(10, 10, 28, 28).permute(0, 2, 1, 3).contiguous().view(280, 280)\n img_fake = img_fake.cpu().numpy()\n plt.figure(figsize=(8, 8))\n plt.imshow(img_fake)\n plt.gca().grid(False)\n plt.gca().set_axis_off()\n```\n\n### Examining the categorical latent code\nThe 10x10 grid below shows how the continuous latent code affects the generated images. The continuous latent code has 2 dimensions, one varies from -1 to 1 along the horizontal axis and the other along the vertical axis. The noise vector $z$ is kept constant for each generation. \n\nThe slider on top of the plot controls the 1 position in the categorical latent code.\n\n\n```\n@ipywidgets.interact(index=(0, 9, 1))\ndef generate(index):\n k.fill_(0.)\n k[:, index] = 1\n\n with torch.no_grad():\n latc = torch.cat([z, k, c], dim=1)\n img_fake = nets['G'](latc)\n img_fake = img_fake.view(10, 10, 28, 28).permute(0, 2, 1, 3).contiguous().view(280, 280)\n img_fake = img_fake.cpu().numpy()\n plt.figure(figsize=(8, 8))\n plt.imshow(img_fake)\n plt.gca().grid(False)\n plt.gca().set_axis_off()\n```\n\n\n interactive(children=(IntSlider(value=4, description='index', max=9), Output()), _dom_classes=('widget-interac…\n\n\n\n```\n\n```\n", "meta": {"hexsha": "718c92e0821088090bb153389f7d973b84afdac3", "size": 404889, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "information-maximising-gan.ipynb", "max_stars_repo_name": "arayabrain/Tutorials", "max_stars_repo_head_hexsha": "1447f9af188932a7761616ca9d1ea9ca565cdbc2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "information-maximising-gan.ipynb", "max_issues_repo_name": "arayabrain/Tutorials", "max_issues_repo_head_hexsha": "1447f9af188932a7761616ca9d1ea9ca565cdbc2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "information-maximising-gan.ipynb", "max_forks_repo_name": "arayabrain/Tutorials", "max_forks_repo_head_hexsha": "1447f9af188932a7761616ca9d1ea9ca565cdbc2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 241.4364937388, "max_line_length": 167157, "alphanum_fraction": 0.8939832892, "converted": true, "num_tokens": 9096, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733885, "lm_q2_score": 0.22815650216092537, "lm_q1q2_score": 0.1060703163736701}}
{"text": "+ This notebook is part of *Final exam review* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n+ Created by me, Dr Juan H Klopper\n + Head of Acute Care Surgery\n + Groote Schuur Hospital\n + University Cape Town\n + Email me with your thoughts, comments, suggestions and corrections \nLinear Algebra OCW MIT18.06 IPython notebook [2] study notes by Dr Juan H Klopper is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License .\n\n+ [1] OCW MIT 18.06 \n+ [2] Fernando Pérez, Brian E. Granger, IPython: A System for Interactive Scientific Computing, Computing in Science and Engineering, vol. 9, no. 3, pp. 21-29, May/June 2007, doi:10.1109/MCSE.2007.53. URL: http://ipython.org\n\n\n```python\nfrom IPython.core.display import HTML, Image\ncss_file = 'style.css'\nHTML(open(css_file, 'r').read())\n```\n\n\n\n\nT A is same as determinant of AAT \n + False\n + AT A is invertible\n + If *r* = *n* (independent columns of A) then TRUE\n + AAT A is positive definite\n + False (it is going to be 3 × 3, but still with only rank 2)\n\n\n```python\nA = Matrix([[0, 0], [1, 0], [0, 1]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 0\\\\1 & 0\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\n(A.transpose() * A).inv()\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]$$\n\n\n\n\n```python\n(A.transpose() * A).det() == (A * A.transpose())\n```\n\n\n\n\n False\n\n\n\n\n```python\nA * A.transpose()\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & 0 & 0\\\\0 & 1 & 0\\\\0 & 0 & 1\\end{matrix}\\right]$$\n\n\n\n+ Prove that AT *y* = *c* has at least one solution for every *c* and in fact infinitely many solution for every *c*\n + It has at least one solution because the new number of rows (*n*) is equal to *r*\n + The dimension of the nullspace of AT is *m* - *r*, which in our example here would be > 0, thus infinitely many solutions\n\n### Question 2\n\n+ Suppose we have a matrix A with columns containing vectors *v*1 , *v*2 , and *v*3 \n\n+ Solve A**x** = *v*1 - *v*2 + *v*3 \n + This is simple multiplication by columns\n $$ x=\\begin{bmatrix}1\\\\-1\\\\1\\end{bmatrix} $$\n\n+ Suppose *v*1 - *v*2 + *v*3 = 0\n + Is the solution unique or are there more\n + Uniqueness means nothing in the nullspace except the zero vector, so in this cane the solutions are not unique\n+ Suppose the columns are orthonormal (would be called *q*1 , *q*2 , *q*3 )\n + What combination of *v*1 and *v*2 are closet to *v*3 ?\n + Zero for each *v*1 and *v*2 \n\n### Question 3\n\n+ Consider the Markov matrix\n$$ \\begin{bmatrix}0.2&0.4&0.3\\\\0.4&0.2&0.3\\\\0.4&0.4&0.4\\end{bmatrix} $$\n\n+ Calculate the eigenvalues\n + The matrix is singular (note how ½ of columns 1 plys ½ of column 2 equals columns 3) so one eigenvalue will be zero\n + Another must be 1\n + The trace adds to 0.8 and so must the sums of the eigenvalues, thus the last eigenvalue is -0.2\n\n+ If for the following the *u*(0) vector is as indicated, what would teh solution be after *k* steps?\n$$ {u}_{k}={A}^{k};\\quad u\\left({0}\\right)=\\begin{bmatrix}0\\\\10\\\\0\\end{bmatrix} $$\n + The following will hold\n $$ {u}_{k}={A}^{k};\\quad u\\left({0}\\right)={c}_{1}{\\lambda}_{1}^{k}{x}_{1}+{c}_{2}{\\lambda}_{2}^{k}{x}_{2}+{c}_{3}{\\lambda}_{3}^{k}{x}_{3} \\\\ {u}_{k}={A}^{k};\\quad u\\left({0}\\right)=0+{c}_{2}\\left({1}\\right){x}_{2}+{c}_{3}\\left({-0.2}\\right)^{k}{x}_{3} $$\n + So at ∞ the only term that survives is *c*2 *x*2 \n + Indeed, the key eigenvalue in any Markov matrix is 1\n\n+ Consider the eigenvector and calculate *u* at ∞\n + We already know that we have to use the λ = 1 eigenvalue\n + The distribution at ∞ will be as follows (see python code below)\n $$ u\\left({\\infty}\\right)=\\begin{bmatrix}3\\\\3\\\\4\\end{bmatrix} $$\n\n\n```python\nA = Matrix([[0.2, 0.4, 0.3], [0.4, 0.2, 0.3], [0.4, 0.4, 0.4]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}0.2 & 0.4 & 0.3\\\\0.4 & 0.2 & 0.3\\\\0.4 & 0.4 & 0.4\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.eigenvects() # Looking for eigenvector of eigenvalue 1\n# Have to distribute the totals into 10 (were 10 total intiallly)\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}-0.2, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}-1.0\\\\1.0\\\\0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}0, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}-0.5\\\\-0.5\\\\1.0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}1.0, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}0.75\\\\0.75\\\\1.0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n### Question 4\n\n+ Calculate the projection onto the following line\n$$ a=\\begin{bmatrix}4\\\\-3\\end{bmatrix} $$\n + The projection matrix is\n $$ P=\\frac{{a}{a}^{T}}{{a}^{T}{a}} $$\n\n\n```python\na = matrix([[4], [-3]]) # Using scipy\n(a * transpose(a)) / (transpose(a) * a)\n```\n\n\n\n\n matrix([[ 0.64, -0.48],\n [-0.48, 0.36]])\n\n\n\n+ Consider the matrix with eigenvalues 0 and 3 and the following eigenvectors\n$$ 0,\\begin{bmatrix}1\\\\2\\end{bmatrix}\\quad 3,\\begin{bmatrix}2\\\\1\\end{bmatrix} $$\n + We use the following decomposition\n $$ A={S}{\\Lambda}{S}^{-1} $$\n\n\n```python\nS = matrix([[1, 2], [2, 1]])\nL = matrix([[0, 0], [0, 3]])\nS_inv = inv(S)\n```\n\n\n```python\nA = S * L * S_inv\nA\n```\n\n\n\n\n matrix([[ 4., -2.],\n [ 2., -1.]])\n\n\n\n+ Give a 2 × 2 matrix A such that A ≠ BT B for any B\n + BT is always symmetric, so A can be any non-symmetric matrix\n\n+ A matrix that has orthogonal eigenvectors, but is not symmetric\n + Any skew-symmetric matrix (transpose = negative of matrix)\n $$ \\begin{bmatrix}0&1\\\\-1&0\\end{bmatrix} $$\n + Any orthogonal matrix\n $$ \\begin{bmatrix}\\cos&-\\sin\\\\\\sin&\\cos\\end{bmatrix} $$\n\n### Question 5\n\n+ Consider the following system A**x**=**b**, with the least squares solution shown and calculate the projection of **b** onto the columnspace of A\n$$ \\begin{bmatrix} 1 & 0 \\\\ 1 & 1 \\\\ 1 & 2 \\end{bmatrix}=\\begin{bmatrix} c \\\\ d \\end{bmatrix}=\\begin{bmatrix} 3 \\\\ 4 \\\\ 1 \\end{bmatrix}, \\quad \\begin{bmatrix} \\hat { c } \\\\ \\hat { d } \\end{bmatrix}=\\begin{bmatrix} \\frac { 11 }{ 3 } \\\\ -1 \\end{bmatrix} $$\n + The least square solution is given, so simply multiply each entry by its column\n $$ \\frac{ 11 }{ 3 } \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\end{bmatrix}-1\\begin{bmatrix} 0 \\\\ 1 \\\\ 2 \\end{bmatrix} $$\n\n+ Calculate a different vector **b** such that all the least square solutions are zero\n + This requires **b** to be orthogonal to those columns, such as the following\n $$ \\begin{bmatrix}1\\\\-2\\\\1\\end{bmatrix} $$\n\n### Question 6 (from recitation)\n\n+ Consider then 3 × 3 matrix A, with λ1 =1 and λ2 =2 and the first two pivots *d*1 =*d*2 =1\n$$ A=\\begin{bmatrix}1&0&1\\\\0&1&1\\\\1&1&0\\end{bmatrix} $$\n\n+ Find λ3 and *d*3 \n + The sum of the eigenvalues must equal the trace, thus λ3 =-1\n + Constant multiples of a row subtracted from another won't change the determinant leaving *d*1 ×*d*2 ×*d*3 =|A| (just watching out for singular matrices which will have a zero on the main diagonal; here though we have three non-zero eigenvalues, so the matrix is not-singular), leaving *d*3 =-2 (product of eigenvalues is also the determinant of A)\n\n+ Calculate the smallest *a*33 entry that will make positive semi-definite\n + For positive definite the eigenvalues must all be ≥ zero\n + The determinant must also be ≥ 0\n\n\n```python\na33 = symbols('a33')\nA = Matrix([[1, 0, 1], [0, 1, 1], [1, 1, a33]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 0 & 1\\\\0 & 1 & 1\\\\1 & 1 & a_{33}\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.det() # Thus a33 must be grteater tha or equal to 2\n```\n\n\n\n\n$$a_{33} - 2$$\n\n\n\n+ Calculate the smallest values of *c* such that the following is still positive semi-definite\n$$ A-cI $$\n + We can calculate the determinant using sympy (see below) or we can make use of the fact that adding a constant multiple of the identity matrix will only add that constant to each eigenvalue, leaving the eigenvectors intact\n $$ 1+c,\\quad 2+c,\\quad -1+c $$\n + Each must be ≥ 0, so the smallest value of *c* is 1\n\n\n```python\nc = symbols('c')\nA = Matrix([[1, 0, 1], [0, 1, 1], [1, 1, 0]])\n(A - c * eye(3))\n```\n\n\n\n\n$$\\left[\\begin{matrix}- 1.0 c + 1 & 0 & 1\\\\0 & - 1.0 c + 1 & 1\\\\1 & 1 & - 1.0 c\\end{matrix}\\right]$$\n\n\n\n\n```python\n(A - c * eye(3)).det() # From here we can calulcate the smallest value of c such\n# that the determinant is still greater than or equal to zero\n```\n\n\n\n\n$$- 1.0 c^{3} + 2.0 c^{2} + 1.0 c - 2$$\n\n\n\n\n```python\nf = -c ** 3 + 2 * c ** 2 + c - 2\nf\n```\n\n\n\n\n$$- c^{3} + 2 c^{2} + c - 2$$\n\n\n\n\n```python\nsolve(f, c) # solve the equation f for the variable c\n```\n\n\n\n\n$$\\begin{bmatrix}-1, & 1, & 2\\end{bmatrix}$$\n\n\n\n+ Consider now one of the starting vectors *u*0 below and with *u*k+1 = ½A*u*k calculate the limiting behavior of *u*k as *k* approaches ∞\n$$ {u}_{0}=\\begin{bmatrix}3\\\\0\\\\0\\end{bmatrix},\\quad\\begin{bmatrix}0\\\\3\\\\0\\end{bmatrix},\\quad\\begin{bmatrix}0\\\\0\\\\3\\end{bmatrix} $$\n + Notice that ½ is a Markov matrix\n + We cannot be sure that there will be a steady state as there are zero entries in ½A\n + Multiplying a matrix by a constant scalar will not change the eigenvectors, but will change the eigenvalues by the same scalar multiple and we will have λ1 =½ and λ2 =1 and λ3 =-½\n + We do have an eigenvalue of 1, so we will reach a steady-state\n + The eigenvector of λ2 =1 is the following (see below)\n $$ \\begin{bmatrix}1\\\\1\\\\1\\end{bmatrix} $$\n + This already sums to 3, so will be *u*∞ \n\n\n```python\n\n```\n", "meta": {"hexsha": "eae67a86f3b3148be89c01f382c765abced0e1fc", "size": 25812, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/III_10_Final_exam_review.ipynb", "max_stars_repo_name": "solomonxie/jupyter-notebooks", "max_stars_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2021-02-13T05:52:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-08T09:52:35.000Z", "max_issues_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/III_10_Final_exam_review.ipynb", "max_issues_repo_name": "solomonxie/jupyter-notebooks", "max_issues_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "forks/MIT_OCW_Linear_Algebra_18_06-master/III_10_Final_exam_review.ipynb", "max_forks_repo_name": "solomonxie/jupyter-notebooks", "max_forks_repo_head_hexsha": "65999f179e037242138de72f512dda4bf00c7379", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-09T15:41:33.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T07:47:40.000Z", "avg_line_length": 29.1661016949, "max_line_length": 708, "alphanum_fraction": 0.4920579575, "converted": true, "num_tokens": 4733, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42632159254749036, "lm_q2_score": 0.24798742624020276, "lm_q1q2_score": 0.10572239448647654}}
{"text": "# What do word vectors represent?\n\nOn Monday we saw the result of running a word embedding algorithm on two collections. We \"embed\" words in a vector space, such that words that are subtitutable (\"ship\" and \"boat\") or that occur together (\"Stop\" and \"thief!\").\n\nIn today's work we will look at the intuition for how the properties of embedding vectors relate to properties we can directly observe in texts. They are really just representations of the words that occur near a given word.\n\nWhat can we tell about a word from the words that occur near it?\n\n\n```python\nimport numpy, sys, math\nfrom IPython.display import display, clear_output, Markdown, Latex\n\nfrom collections import Counter\n```\n\n\n```python\n## Helper functions to nicely display numeric word scores\n\ndef show(sorted_words, n=20):\n markdown_table = \"|Score | Word|\\n|---:|:---|\\n\"\n for score, word in sorted_words[:n]:\n markdown_table += \"|{:.3f}|{}|\\n\".format(score, word)\n display(Markdown(markdown_table))\n \ndef show_counter(counter, n=20):\n markdown_table = \"|Count | Word|\\n|---:|:---|\\n\"\n for word, score in counter.most_common(n):\n markdown_table += \"|{}|{}|\\n\".format(score, word)\n display(Markdown(markdown_table))\n```\n\nFirst we'll read the texts. I've already split the tokens with Spacy and written the output to a file with one sentence per line, so punctuation will be included as distinct tokens.\n\nWhile we read this, we'll also count the frequency of each word type in `all_counter`.\n\n\n```python\ntext_filename = \"../data/Sagas/sagas_en_split.txt\"\n\nsentences = []\nall_counter = Counter()\n\nwith open(text_filename, encoding=\"utf-8\") as reader:\n for line in reader:\n ## The file has already been tokenized, so we can split on whitespace\n tokens = line.strip().split()\n all_counter.update(tokens)\n \n sentences.append(tokens)\n```\n\nLet's start by looking at the context that words appear in. The next block defines a *key word in context* (KWIC) view.\n\n\n```python\nwindow_size = 5\n```\n\n\n```python\ndef keyword_in_context(query):\n table_markdown = \"|left context|word|right context|\\n|--:|--|:--|\\n\"\n for sentence in sentences:\n \n if not query in sentence:\n continue\n \n for i, word in enumerate(sentence):\n if word == query:\n start = max(i-window_size, 0)\n left_context = sentence[start:i]\n right_context = sentence[(i+1):(i+window_size+1)]\n table_markdown += \"|{}|{}|{}|\\n\".format(\" \".join(left_context), word, \" \".join(right_context))\n \n display(Markdown(table_markdown))\n```\n\n### Part 1\n\nI've given you an example, for *Shetland*, a chain of islands north of Scotland near the Orkney islands. \n\nAdd 10 additional cells, each with one call to the `keyword_in_context` function. Choose five pairs of words that you think might be similar (e.g. *Shetland* and *Orkneys*). Select a variety of parts of speech, such as nouns, verbs, adjectives, prepositions, and proper names.\n\nDiscuss what you notice about the similarities and differences between the contexts of these words.\n\n**Answer here**\n\n\n```python\nkeyword_in_context(\"Shetland\")\n```\n\n\n```python\n# add more `keyword_in_context` cells here\n```\n\nNow let's look at the distribution of words immediately preceding (*left* or *previous* context) and immediately following (*right* or *next* context) a word. This block creates two dictionaries, which map a string to the `Counter` of the words that follow that word and precede it, respectively.\n\n\n```python\nprevious_context_counters = {} # count words that precede the key\nnext_context_counters = {} # count words that follow the key\n\nfor sentence in sentences:\n for i in range(len(sentence) - 1): # stop at the next-to-last token\n word = sentence[i]\n next_word = sentence[i+1]\n \n if not word in next_context_counters:\n next_context_counters[word] = Counter()\n if not next_word in previous_context_counters:\n previous_context_counters[next_word] = Counter()\n \n next_context_counters[word][next_word] += 1\n previous_context_counters[next_word][word] += 1\n```\n\n### Part 2\n\nIn the next code cell I'm demonstrating how to get the most frequent following words for a query word.\n\nUse this function like a \"predictive text\" feature. Generate two Viking sentences of 10-20 words.\n* In the first sentence, start with \"Then\" and pick the most frequent following word. Record your sentence, and comment on why always picking the most common word might not be a good idea.\n* In the second sentence, start with \"Then\" but choose the next word based on both the frequency distribution and your artistic sensibilities.\n\n**First sentence here**\n\n\n**Comment on first sentence**\n\n\n**Second sentence here**\n\n\n\nAdd cells to show previous *and* next context words for at least 10 more words. Use a selection of nouns, verbs, adjectives, prepositions, and names. These may be the same words you looked at before, but you may also want to add additional examples.\n\nDiscuss whether the words to the right or left of a word indicate its part of speech. Cite examples to support your argument. Are the two contexts equally informative for a given part of speech, and is that consistent across different parts of speech?\n\n**Answer here**\n\n\n```python\nshow_counter(next_context_counters[\"she\"])\n```\n\n\n```python\nshow_counter(previous_context_counters[\"she\"])\n```\n\n\n```python\n## add cells here\n```\n\nNext we'll look at sums over the full five-word context window. This code creates one `Counter` for each word type, which adds up all the words that appear within the window around the word.\n\n\n```python\nword_context_counters = {}\n\nfor sentence in sentences:\n \n for i, word in enumerate(sentence):\n start = max(i-window_size, 0)\n left_context = sentence[start:i]\n right_context = sentence[(i+1):(i+window_size+1)]\n \n if not word in word_context_counters:\n word_context_counters[word] = Counter()\n \n word_context_counters[word].update(left_context)\n word_context_counters[word].update(right_context)\n```\n\n### Part 3\n\nThis next cell is an example showing output for the full context counts of a word, essentially adding up all the words you saw in the KWIC view earlier.\n\nShow output for at least 10 words, from a mix of parts of speech.\n\nDiscuss how this view of a word's context differs from the single-previous-word and single-next-word context views we saw in Part 2.\n\n**Answer here**\n\n\n```python\nshow_counter(word_context_counters[\"Shetland\"], 15)\n```\n\n\n```python\n## add cells here\n```\n\nFinally, let's look at a way of comparing the word frequencies we actually observed to the word frequencies in the collection as a whole. We'll use a method called *pointwise mutual information*.\n\nPMI is closely related to KL divergence. In this case, the two distributions we want to compare are the probability of context word $c$ *near* word $w$ and the probabilty of $c$ anywhere. The word *the* is common throughout the collection, so we expect to see it. This metric measures the ratio between the frequency that we actually saw it in the context and our expectation for any random context.\n\nNotation: \n* $N(c|w)$ is `word_context_counters[w][c]`\n* $N(w)$ is `sum(word_context_counters[w].values()`\n* $N(c)$ is `all_counter[c]`\n* $N$ is `all_sum`\n\n$$\n\\begin{align}\nPMI(c, w) & = P(c, w) \\log \\frac{P(c,w)}{P(c)P(w)} \\\\\n& = P(c, w) \\log \\frac{P(c|w)P(w)}{P(c)P(w)} \\\\\n& = P(c, w) \\log \\frac{P(c|w)}{P(c)} \\\\\n& \\propto N(c|w) \\log \\frac{\\frac{N(c|w)}{N(w)} }{ \\frac{N(c)}{N} } \\\\\n& = N(c|w) \\log \\frac{N(c|w)N}{N(w)N(c)}\n\\end{align}$$\n\n\n\n```python\ndef log_ratio(word):\n counter = word_context_counters[word]\n \n all_sum = sum(all_counter.values()) ## N\n word_sum = sum(counter.values()) ## N(w)\n \n comparisons = []\n for c in counter.keys():\n score = counter[c] * math.log((counter[c] * all_sum) / (word_sum * all_counter[c]))\n comparisons.append((score, c))\n \n return sorted(comparisons, reverse=True)\n\n```\n\n### Part 4\n\nCompare results using this `log_ratio` function to the output of the `nearest` function used in Monday's notebook.\n\nProvide some examples, and describe how they are similar or different from the output of the word embedding. If there are \"missing\" words in the output here that are close in the embedding space, show the `log_ratio` output for those words. Do the two words have similar context words? Describe whether this is true and mention examples.\n\n**Answer here**\n\n\n```python\n## 'spae' is a Scots word for prophecy. Gunnhilda was the wife of Eric Bloodaxe.\n## She was ordered to be drowned in a bog by King Harald Bluetooth, the namesake\n## of the wireless standard. Think about that next time you put on some headphones.\n\nshow(log_ratio(\"queen\"))\n```\n\n\n```python\n## add cells with examples here\n```\n\n**Extra bonus for those interested** The embedding algorithm adds an additional step: subsampling the most frequent words. Here's code that generates this subsampling probability.\n\n\n```python\nsampling_probs = {}\nall_sum = sum(all_counter.values())\nfor word in all_counter.keys():\n p_word = all_counter[word] / all_sum\n score = 1.0 / (10000 * p_word)\n sampling_probs[word] = math.sqrt(score) + score\n```\n", "meta": {"hexsha": "f3be82e8f5b401f903dc19253ea38f7fdf386067", "size": 14544, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "week11/KeywordsToEmbeddings.ipynb", "max_stars_repo_name": "mimno/info-3350-fall-2019", "max_stars_repo_head_hexsha": "b4e11340f753b22ef9d4db6ebe2fdbbd9e99b156", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2019-11-05T17:34:38.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-02T19:37:03.000Z", "max_issues_repo_path": "week11/KeywordsToEmbeddings.ipynb", "max_issues_repo_name": "mimno/info-3350-fall-2019", "max_issues_repo_head_hexsha": "b4e11340f753b22ef9d4db6ebe2fdbbd9e99b156", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "week11/KeywordsToEmbeddings.ipynb", "max_forks_repo_name": "mimno/info-3350-fall-2019", "max_forks_repo_head_hexsha": "b4e11340f753b22ef9d4db6ebe2fdbbd9e99b156", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 19, "max_forks_repo_forks_event_min_datetime": "2019-09-04T15:23:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-01-10T23:16:31.000Z", "avg_line_length": 32.1769911504, "max_line_length": 408, "alphanum_fraction": 0.5736386139, "converted": true, "num_tokens": 2247, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207956, "lm_q2_score": 0.21469141408759984, "lm_q1q2_score": 0.10566856685503712}}
{"text": "```python\n#from IPython.display import Image\n#Image(filename='i_could_care_less.png') \n#
\nfrom IPython.display import Image\nfrom IPython.display import HTML\nhtml1 = '
'\nHTML(html1)\n\n#from IPython.display import Image\n#from IPython.core.display import HTML \n#Image(filename= \"i_could_care_less.png\",width=500, height=500)\n```\n\n\n\n\n
\n\n\n\n# Word Representation With One-Hot Vectors\n\nOne-hot encoding is the most common, most basic way to turn a token into a vector. It consists in associating a unique integer index to every word, then turning this integer index $i$ into a binary vector of size $V$, which is the size of our vocabulary, that would be all-zeros except for the $i$-th entry, which would be 1.\n\n\n```python\nimport numpy as np\nsamples = ['The cat sat on the mat.', 'The dog ate my homework.']\ntoken_index = {}\nfor sample in samples:\n for word in sample.split():\n if word not in token_index:\n token_index[word] = len(token_index) + 1\n\nsentence = \"the cat ate the god\"\nseq = []\nfor word in sentence.split():\n one_hot = np.zeros((1,len(token_index)))\n if word not in token_index:\n seq.append(one_hot.squeeze())\n else:\n one_hot[0,token_index[word]-1] = one_hot[0,token_index[word]-1] + 1\n seq.append(one_hot.squeeze())\n```\n\n\n```python\nseq\n```\n\n\n\n\n [array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]),\n array([0., 0., 0., 0., 0., 0., 1., 0., 0., 0.]),\n array([0., 0., 0., 0., 0., 0., 0., 1., 0., 0.]),\n array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]),\n array([0., 1., 0., 0., 0., 0., 0., 0., 0., 0.])]\n\n\n\n\n```python\nimport numpy as np\nwith open('cats100.test.txt') as file_handler:\n data = file_handler.read()\n\ntoken_idx = {}\nfor word in data.split():\n if word not in token_idx:\n token_idx[word] = len(token_idx) + 1\n\nsentence = \"Geçtiğimiz zamanlarda kötü olaylar yaşandı\"\none_hot_sentence = np.zeros((len(sentence.split()),len(token_idx)),dtype=np.int32)\nfor word_idx,word in enumerate(sentence.split()):\n one_hot_sentence[word_idx,token_idx[word] - 1] = 1\n```\n\n\n \n Figure is taken from Stanford cs-230 cheatsheet \n \n\n There are two major issues with this approach. First issue is the curse of dimensionality, which refers to all sorts of problems that arise with data in high dimensions. This requires exponentially large memory space. Most of the matrix is taken up by zeros, so useful data becomes sparse. Imagine we have a vocabulary of 50,000. (There are roughly a million words in English language.) Each word is represented with 49,999 zeros and a single one, and we need 50,000 squared = 2.5 billion units of memory space. Not computationally efficient.\n \n\nSecond issue is that every one hotted vector is orthogonal to each other. You cannot measure the\nsimilarity (like cosine similarity) on this vectors.\n\n\nThose vectors can be visualized in 3 or 2-dimensional space as an example. In $\\mathbb{R}^3$ (in other words, vocabulary size of 3, $\\mid V \\mid=3$), the word vectors become our span set which is \n$\\left\\{\\begin{bmatrix} 1\\\\0\\\\0\\end{bmatrix},\n\\begin{bmatrix} 0\\\\1\\\\0\\end{bmatrix},\n\\begin{bmatrix} 0\\\\0\\\\1\\end{bmatrix}\\right\\}$. The span set is linearly independent set. Therefore we cannot compute similarity metrics. The vectors $\\vec{u_1}, \\vec{u_2}, \\vec{u_3}$ are orthogonal. Similarity metrics gives the result of zero. For example the cosine similarity:\nsimilar contexts tend to have similar meanings. The link between similarity and words are distributed and similarity in what they mean is called distributional hypothesis or distributional semantics in the field of Computational Linguistics. So what can be counted when we say similar contexts? For example if you surf on the Wikipedia page of linguistics, the words in this page somehow related with each other in the context of linguistics. This was formulated firsty by Martin Joos (Description of Language Design, 1950), Zellig Harris (Distributional Structure, 1954), John Rupert Firth (Applications of General Linguistics, 1957).\n\n\nSome words have similar meanings, for example word cat and dog similar . Also, words can be antonyms , for example hot and cold. And words have connotations (TR: çağrışım), for example happy->positive connotation and sad->negative connotation. Can you feel the similarity of words, [study, exam, night, FF]?\n\n\nAlso each word can have multiple meanings. The word mouse can refeer to the rodent or the cursor control device. We call each of these aspects of the meaning of mouse a word sense . In other words words can be polysemous (have multiple senses), which can lead us to make word interpretations difficult! \nWord Sense Disambiguation : \"Mouse info\" (person who types this into a web search engine, looking for a pet info or a tool?) (determining which sense of a word is being used in a particular context)\n\nThe word **similarity** is very useful in larger semantics tasks. Knowing how similar two words are can help in computing how similar the meaning of two phrases or sentences are, a very important component of natural language understanding tasks like **question answering**, **summarization** etc.\n\n| Word1 | Word2 | Similarity (0-10) |\n| ----------- | ----------- | ----------- |\n| Vanish | Disappear | 9.8 |\n| Behave | Obey | 7.3 |\n| Belief | Impression | 5.95 |\n| Muscle | Bone | 3.65 |\n| Modest | Flexible | 0.98 |\n| Hole | Agreement | 0.3 |\n\nWe should look at **word relatedness** , the meaning of two words can be related in ways other than similarity. One such class of connections is called word **relatedness**, also traditionally called word **association** in pysch.\n\n- The word *cup* and *coffee*.\n- The word *inzva* and *deep learning*.\n\nAlso words can affective meanings. Osgood et al. 1957, proposed that words varied along three important dimensions of affective meaning: *valence, arousal, dominance*.\n- **valence**: the pleasantness of the stimulus.\n- **arousal**: the intensity of emotion provoked by the stimulus.\n- **dominance**: the degree of control exerted by the stimulus.\n\nExamples: \n- happy(1) $\\uparrow$, satisfied(1) $\\uparrow$; annoyed(1) $\\downarrow$, unhappy(1)$\\downarrow$\n- excited(2) $\\uparrow$, frenzied(2) $\\uparrow$; relaxed(1) $\\downarrow$, calm(2) $\\downarrow$\n- important(3)$\\uparrow$, controlling(3)$\\uparrow$; awed(3)$\\downarrow$, influenced(3)$\\downarrow$\n\n*Question: does word embeddings has these dimesions?*\n\n# Word Embeddings\n\nHow can we build a computational model that successfully deals with the different aspects of word meaning we saw above (word senses, word similarity, word relatedness, connotation etc.)?\n\n**Instead of representing words with one-hot vector, sparse; with word embeddings we represents words with dense vectors**. \n\n**The idea of vector semantics is thus to represent a word as a point in some multidimensional semantic space.** Vectors for representing words are generally called **embeddings**. We **LEARN** this embeddings form an arbitrary context.\n\n\n\nMain two advantages of this word embeddings are:\n\n- Now we represent words with dense vectors, which leads low memory requirements.\n\n\n \n Figure is taken from Stanford cs-230 cheatsheet \n \n\n- We can now calculate similarity metrics on these vectors!\n\n## Visualizing Word Embeddings\n\nWord embeddings can be visualized with various dimensionality reduction/matrix factorization algorithms.\n\n\n\n \n \n \n
\n\n\n- left-figure source: [Zero-Shot Learning Through Cross-Modal Transfer (Socher et al., 2013, NeurIPS)](https://nlp.stanford.edu/~socherr/SocherGanjooManningNg_NIPS2013.pdf)\n- right-figure source: [Word representations: A simple and general method for semi-supervised learning (Turian et al., 2010)](http://metaoptimize.s3.amazonaws.com/cw-embeddings-ACL2010/embeddings-mostcommon.EMBEDDING_SIZE=50.png)\n\n\n \n \n \n
\n\n\n- left-figure source: [Natural Language Processing (almost) from Scratch (Collobert et al., 2011)](https://arxiv.org/abs/1103.0398v1.pdf)\n- right-figure source: [Bilingual Word Embeddings for Phrase-Based Machine Translation (Socher et al., 2013, EMNLP)](https://ai.stanford.edu/~wzou/emnlp2013_ZouSocherCerManning.pdf)\n\n## Using Word Embeddings\n\n### Named Entity Recognition (NER)\nIn Natural language processing, Named Entity Recognition (NER) is a process where a sentence or a chunk of text is parsed through to find entities that can be put under categories like names, organizations, locations, quantities, monetary values, percentages, etc. Traditional NER algorithms included only names, places, and organizations.\n\nSince the embeddings can capture word senses etc., it is practical and beneficial to use word embeddings in NER task. Embeddings can capture entity informations while capturing word relations.\n\n\n \n \n
\n\n\nfigure sources: [link](https://towardsdatascience.com/named-entity-recognition-ner-meeting-industrys-requirement-by-applying-state-of-the-art-deep-698d2b3b4ede)\n\n### Transfer Learning\n\n- To learn word embeddings, huge size of training data is always useful. For example GloVe is trained on 5 separate corpora:\n * 2010 Wikipedia dump with 1 billion tokens\n * 2014 Wikipedia dump with 1.6 billion tokens\n * Gigaword 5 which has 4.3 billion tokens\n * the combination Gigaword5 + Wikipedia2014, which has 6 billion tokens\n * 42 billion tokens of web data, from Common Crawl\n\n \n \n
\n\n[A Fast and Accurate Dependency Parser using Neural Networks (Chen et al., 2014)](https://www.aclweb.org/anthology/D14-1082/)\n\nright-figure source [CS224n Part IV](https://web.stanford.edu/class/cs224n/readings/cs224n-2019-notes04-dependencyparsing.pdf)\n\n### Representation Learning\n\nVarious tasks can be modeled with representations. Since words can be represented by embeddings, images can be (or even signals/audio) represented by a latent space $z$. Autoencoders is a way to learn latent representation of data.\n\n\n
\n\n \n \n \n
\n\n## Semantic Properties Of Embeddings\n\nWord embeddings have very important property: analogies. Analogy is another semantic property of embeddings that can capture relational meanings. Simply in words, analogy is to find **X**:\n\n- **A is to B as C is to X**\n\nFor example **“woman is to queen as man is to X**. In this example **X** should be the word *king*.\n\nInterestingly, such embeddings exhibit seemingly linear behaviour in analogies. This linear behaviour can be formulated as\n\n- $w_a$ is to $w_a'$ as $w_b$ is to $w_b'$ $\\rightarrow \\rightarrow \\rightarrow$ $w_a' - w_a + w_b \\approx w_b'$\n\n- vec('*queen*') - vec('*woman*') + vec('*man*') $\\approx$ vec('*king*')\n\nor\n\n- vec('*queen*') - vec('*woman*') $\\approx$ vec('*king*') - vec('*man*')\n\n\nAnother example:\n\n- vec('*Paris*') - vec('*France*') $\\approx$ vec('*Italy*') - vec('*Rome*')\n\n\n\n\n \n \n \n
\n\n- left-figure source: [Linguistic Regularities in Continuous Space Word Representations (Mikolov et al., 2013)](https://www.aclweb.org/anthology/N13-1090.pdf)\n- mid-figure source: [Speech and Language Processing, Daniel Jurafsky, Third Edition](https://web.stanford.edu/~jurafsky/slp3/)\n- right-figure source: [Efficient Estimation of Word Representations in Vector Space (Mikolov etl al., 2013)](https://arxiv.org/pdf/1301.3781.pdf)\n\nDo vector embeddings capture syntactic relationships? Yes. Capture with linear behaviours? Yes.\n\n\n\n \n \n
\n\n- left-figure source: [Linguistic Regularities in Continuous Space Word Representations (Mikolov et al., 2013)](https://www.aclweb.org/anthology/N13-1090.pdf)\n- right-figure source: [Speech and Language Processing, Daniel Jurafsky, Third Edition](https://web.stanford.edu/~jurafsky/slp3/)\n\n\nFor more formal definition of analogy? Check [Analogies Explained: Towards Understanding Word Embeddings (Allen et al., 2019)](https://arxiv.org/pdf/1901.09813.pdf)\n\n## Evaluating Word Vectors\n\n- Extrinsic Evaluation\n * This is the evaluation on a real task.\n * Can be slow to compute performance.\n * Unclear if the subsystem is the problem, or our system.\n * If replacing subsystem improves performance, the change is likely good.\n * NER, Question Answering etc.\n\n\n- Intrinsic Evaluation\n * Fast to compute\n * Helps to understand subsystem\n * Needs positive correlation with real task to determine usefulness\n \n \nSimLex-999 dataset (Hill et al., 2015) gives values on a scale from 0 to 10 by asking humans to judge how similar one word is to another. Other datasets for evaluating word vectors: \n- WordSim 353 \n- TOEFL Dataset\n- SCWS Dataset\n- Word-in-Context (WiC)\n- Miller & Charles Dataset\n- Rubenstein & Goodenough Dataset\n- Stanford Rare Word (RW)\n\n\n \n \n
\n\nSome evaluation metrics from [GloVe: Global Vectors for Word Representation (Pennington et al., 2014)](https://www.aclweb.org/anthology/D14-1162.pdf)\n\n# Learning Word Embeddings\n\n## Embedding Matrix\nEmbedding matrix can be represented as a single matrix $E \\in \\mathbb{R}^{d \\times \\mid V \\mid}$ (or $E \\in \\mathbb{R}^{ \\mid V \\mid \\times d }$, it does not even matter), where d is embedding size and $\\mid V \\mid$ is size of the vocabulary $V$.\n\n\n\" as the proctor started the clock the students opened their ____.\"\n
\n\n \n \n
\n\n- left-figure source: [CS224n lecture 5](http://web.stanford.edu/class/cs224n/slides/cs224n-2021-lecture05-rnnlm.pdf)\n- right-figure source: [Speech and Language Processing, Daniel Jurafsky, Third Edition](https://web.stanford.edu/~jurafsky/slp3/)\n\nFor this task, we are going to represent each of the $N$ prevuios words as a one-hot-vector of length $\\mid V \\mid$.\n\nThe forward equation for neural language model\n\n- Input $x_i \\in R^{1 \\times \\mid V \\mid}$\n\n- Learning word embeddings: $e = concat(x_1 E^T, x_2 E^T, x_3 E^T)$\n * $E \\in \\mathbb{R}^{d \\times \\mid V \\mid}$\n * $e \\in \\mathbb{R}^{1 \\times 3d}$\n \n \n- $h = \\sigma(e W^T + b_1)$\n * $W \\in \\mathbb{R}^{d_h \\times 3d}$\n * $h \\in \\mathbb{R}^{1 \\times d_h}$\n \n \n- $z = h U^T + b_2$\n * $U \\in \\mathbb{R}^{\\mid V \\mid \\times d_h}$\n * $z \\in \\mathbb{R}^{1 \\times \\mid V \\mid}$\n \n \n- $\\hat{y} = softmax(z) \\in \\mathbb{R}^{1 \\times \\mid V \\mid}$\n\n\nThen the model is trained, at each word $w_t$, the negative log likelihood loss is:\n\n$$ L = - \\log p(w_t \\mid w_{(t-1)}, w_{(t-2)}, ..., w_{(t-n+1)}) = softmax(z) $$\n\n\n \n \n
\n\n\nFor example consider this sentence,\n\n \"A change in Quantity also entails a change in Quality\"\nOur target and context pairs for window size of 5:\n\n\n| Sliding window (size = 5) | Target word | Context |\n| ----------- | ----------- | ----------- |\n| \\[A change in\\] | a | change, in |\n| \\[A change in Quantity \\] | change | a, in, quantitiy |\n| \\[A change in Quantity also\\] | in | a, change, quantitiy,also |\n| ... | ... | ... |\n| \\[entails a change in Quality\\] | change | entails, a, in, Quality |\n| \\[a change in Quality\\] | in | a, change, Quality |\n| \\[change in Quality\\] | quality | change, in |\n\nEach context-target pair is treated as a new observation in the data. \n\nFor each position $t=1,..,T$ predict context words within a window of fixed size $m$, given center word $w_j$. In Skip-gram connections we have an objective to maximize, likelihood (or minimize log-likelihood):\n\n
\n\n\n```python\nimport numpy as np\nunig_dist = {'inzva': 0.023, 'deep': 0.12, 'learning': 0.34, 'the': 0.517}\nsum(unig_dist.values())\n```\n\n\n\n\n 1.0\n\n\n\n\n```python\nalpha = 3 / 4\nnoise_dist = {key: val ** alpha for key, val in unig_dist.items()}\nZ = sum(noise_dist.values())\nnoise_dist_normalized = {key: val / Z for key, val in noise_dist.items()}\nnoise_dist_normalized\n```\n\n\n\n\n {'inzva': 0.044813853132981724,\n 'deep': 0.15470428538870049,\n 'learning': 0.33785130228003507,\n 'the': 0.4626305591982827}\n\n\n\n\n```python\nsum(noise_dist_normalized.values())\n```\n\n\n\n\n 1.0\n\n\n\n\n```python\nK = 10\nnp.random.choice(list(noise_dist_normalized.keys()), size=K, p=list(noise_dist_normalized.values()))\n```\n\n\n\n\n array(['the', 'the', 'deep', 'learning', 'the', 'learning', 'the',\n 'inzva', 'the', 'learning'], dtype=' You are a skilled programmer, but bugs still slip into your code. After a particularly difficult implementation of an algorithm, you decide to test your code on a trivial example. It passes. You test the code on a harder problem. It passes once again. And it passes the next, *even more difficult*, test too! You are starting to believe that there may be no bugs in this code...\n\nIf you think this way, then congratulations, you already are thinking Bayesian! Bayesian inference is simply updating your beliefs after considering new evidence. A Bayesian can rarely be certain about a result, but he or she can be very confident. Just like in the example above, we can never be 100% sure that our code is bug-free unless we test it on every possible problem; something rarely possible in practice. Instead, we can test it on a large number of problems, and if it succeeds we can feel more *confident* about our code, but still not certain. Bayesian inference works identically: we update our beliefs about an outcome; rarely can we be absolutely sure unless we rule out all other alternatives. \n\n\n### The Bayesian state of mind\n\n\nBayesian inference differs from more traditional statistical inference by preserving *uncertainty*. At first, this sounds like a bad statistical technique. Isn't statistics all about deriving *certainty* from randomness? To reconcile this, we need to start thinking like Bayesians. \n\nThe Bayesian world-view interprets probability as measure of *believability in an event*, that is, how confident we are in an event occurring. In fact, we will see in a moment that this is the natural interpretation of probability. \n\nFor this to be clearer, we consider an alternative interpretation of probability: *Frequentist*, known as the more *classical* version of statistics, assume that probability is the long-run frequency of events (hence the bestowed title). For example, the *probability of plane accidents* under a frequentist philosophy is interpreted as the *long-term frequency of plane accidents*. This makes logical sense for many probabilities of events, but becomes more difficult to understand when events have no long-term frequency of occurrences. Consider: we often assign probabilities to outcomes of presidential elections, but the election itself only happens once! Frequentists get around this by invoking alternative realities and saying across all these realities, the frequency of occurrences defines the probability. \n\nBayesians, on the other hand, have a more intuitive approach. Bayesians interpret a probability as measure of *belief*, or confidence, of an event occurring. Simply, a probability is a summary of an opinion. An individual who assigns a belief of 0 to an event has no confidence that the event will occur; conversely, assigning a belief of 1 implies that the individual is absolutely certain of an event occurring. Beliefs between 0 and 1 allow for weightings of other outcomes. This definition agrees with the probability of a plane accident example, for having observed the frequency of plane accidents, an individual's belief should be equal to that frequency, excluding any outside information. Similarly, under this definition of probability being equal to beliefs, it is meaningful to speak about probabilities (beliefs) of presidential election outcomes: how confident are you candidate *A* will win?\n\nNotice in the paragraph above, I assigned the belief (probability) measure to an *individual*, not to Nature. This is very interesting, as this definition leaves room for conflicting beliefs between individuals. Again, this is appropriate for what naturally occurs: different individuals have different beliefs of events occurring, because they possess different *information* about the world. The existence of different beliefs does not imply that anyone is wrong. Consider the following examples demonstrating the relationship between individual beliefs and probabilities:\n\n- I flip a coin, and we both guess the result. We would both agree, assuming the coin is fair, that the probability of Heads is 1/2. Assume, then, that I peek at the coin. Now I know for certain what the result is: I assign probability 1.0 to either Heads or Tails (whichever it is). Now what is *your* belief that the coin is Heads? My knowledge of the outcome has not changed the coin's results. Thus we assign different probabilities to the result. \n\n- Your code either has a bug in it or not, but we do not know for certain which is true, though we have a belief about the presence or absence of a bug. \n\n- A medical patient is exhibiting symptoms $x$, $y$ and $z$. There are a number of diseases that could be causing all of them, but only a single disease is present. A doctor has beliefs about which disease, but a second doctor may have slightly different beliefs. \n\n\nThis philosophy of treating beliefs as probability is natural to humans. We employ it constantly as we interact with the world and only see partial truths, but gather evidence to form beliefs. Alternatively, you have to be *trained* to think like a frequentist. \n\nTo align ourselves with traditional probability notation, we denote our belief about event $A$ as $P(A)$. We call this quantity the *prior probability*.\n\nJohn Maynard Keynes, a great economist and thinker, said \"When the facts change, I change my mind. What do you do, sir?\" This quote reflects the way a Bayesian updates his or her beliefs after seeing evidence. Even — especially — if the evidence is counter to what was initially believed, the evidence cannot be ignored. We denote our updated belief as $P(A |X )$, interpreted as the probability of $A$ given the evidence $X$. We call the updated belief the *posterior probability* so as to contrast it with the prior probability. For example, consider the posterior probabilities (read: posterior beliefs) of the above examples, after observing some evidence $X$:\n\n1\\. $P(A): \\;\\;$ the coin has a 50 percent chance of being Heads. $P(A | X):\\;\\;$ You look at the coin, observe a Heads has landed, denote this information $X$, and trivially assign probability 1.0 to Heads and 0.0 to Tails.\n\n2\\. $P(A): \\;\\;$ This big, complex code likely has a bug in it. $P(A | X): \\;\\;$ The code passed all $X$ tests; there still might be a bug, but its presence is less likely now.\n\n3\\. $P(A):\\;\\;$ The patient could have any number of diseases. $P(A | X):\\;\\;$ Performing a blood test generated evidence $X$, ruling out some of the possible diseases from consideration.\n\n\nIt's clear that in each example we did not completely discard the prior belief after seeing new evidence $X$, but we *re-weighted the prior* to incorporate the new evidence (i.e. we put more weight, or confidence, on some beliefs versus others). \n\nBy introducing prior uncertainty about events, we are already admitting that any guess we make is potentially very wrong. After observing data, evidence, or other information, we update our beliefs, and our guess becomes *less wrong*. This is the alternative side of the prediction coin, where typically we try to be *more right*. \n\n\n\n### Bayesian Inference in Practice\n\n If frequentist and Bayesian inference were programming functions, with inputs being statistical problems, then the two would be different in what they return to the user. The frequentist inference function would return a number, representing an estimate (typically a summary statistic like the sample average etc.), whereas the Bayesian function would return *probabilities*.\n\nFor example, in our debugging problem above, calling the frequentist function with the argument \"My code passed all $X$ tests; is my code bug-free?\" would return a *YES*. On the other hand, asking our Bayesian function \"Often my code has bugs. My code passed all $X$ tests; is my code bug-free?\" would return something very different: probabilities of *YES* and *NO*. The function might return:\n\n\n> *YES*, with probability 0.8; *NO*, with probability 0.2\n\n\n\nThis is very different from the answer the frequentist function returned. Notice that the Bayesian function accepted an additional argument: *\"Often my code has bugs\"*. This parameter is the *prior*. By including the prior parameter, we are telling the Bayesian function to include our belief about the situation. Technically this parameter in the Bayesian function is optional, but we will see excluding it has its own consequences. \n\n\n####Incorporating evidence\n\nAs we acquire more and more instances of evidence, our prior belief is *washed out* by the new evidence. This is to be expected. For example, if your prior belief is something ridiculous, like \"I expect the sun to explode today\", and each day you are proved wrong, you would hope that any inference would correct you, or at least align your beliefs better. Bayesian inference will correct this belief.\n\n\nDenote $N$ as the number of instances of evidence we possess. As we gather an *infinite* amount of evidence, say as $N \\rightarrow \\infty$, our Bayesian results (often) align with frequentist results. Hence for large $N$, statistical inference is more or less objective. On the other hand, for small $N$, inference is much more *unstable*: frequentist estimates have more variance and larger confidence intervals. This is where Bayesian analysis excels. By introducing a prior, and returning probabilities (instead of a scalar estimate), we *preserve the uncertainty* that reflects the instability of statistical inference of a small $N$ dataset. \n\nOne may think that for large $N$, one can be indifferent between the two techniques since they offer similar inference, and might lean towards the computationally-simpler, frequentist methods. An individual in this position should consider the following quote by Andrew Gelman (2005)[1], before making such a decision:\n\n> Sample sizes are never large. If $N$ is too small to get a sufficiently-precise estimate, you need to get more data (or make more assumptions). But once $N$ is \"large enough,\" you can start subdividing the data to learn more (for example, in a public opinion poll, once you have a good estimate for the entire country, you can estimate among men and women, northerners and southerners, different age groups, etc.). $N$ is never enough because if it were \"enough\" you'd already be on to the next problem for which you need more data.\n\n### Are frequentist methods incorrect then? \n\n**No.**\n\nFrequentist methods are still useful or state-of-the-art in many areas. Tools such as least squares linear regression, LASSO regression, and expectation-maximization algorithms are all powerful and fast. Bayesian methods complement these techniques by solving problems that these approaches cannot, or by illuminating the underlying system with more flexible modeling.\n\n\n#### A note on *Big Data*\nParadoxically, big data's predictive analytic problems are actually solved by relatively simple algorithms [2][4]. Thus we can argue that big data's prediction difficulty does not lie in the algorithm used, but instead on the computational difficulties of storage and execution on big data. (One should also consider Gelman's quote from above and ask \"Do I really have big data?\" )\n\nThe much more difficult analytic problems involve *medium data* and, especially troublesome, *really small data*. Using a similar argument as Gelman's above, if big data problems are *big enough* to be readily solved, then we should be more interested in the *not-quite-big enough* datasets. \n\n\n### Our Bayesian framework\n\nWe are interested in beliefs, which can be interpreted as probabilities by thinking Bayesian. We have a *prior* belief in event $A$, beliefs formed by previous information, e.g., our prior belief about bugs being in our code before performing tests.\n\nSecondly, we observe our evidence. To continue our buggy-code example: if our code passes $X$ tests, we want to update our belief to incorporate this. We call this new belief the *posterior* probability. Updating our belief is done via the following equation, known as Bayes' Theorem, after its discoverer Thomas Bayes:\n\n\\begin{align}\n P( A | X ) = & \\frac{ P(X | A) P(A) } {P(X) } \\\\\\\\[5pt]\n& \\propto P(X | A) P(A)\\;\\; (\\propto \\text{is proportional to } )\n\\end{align}\n\nThe above formula is not unique to Bayesian inference: it is a mathematical fact with uses outside Bayesian inference. Bayesian inference merely uses it to connect prior probabilities $P(A)$ with an updated posterior probabilities $P(A | X )$.\n\n##### Example: Mandatory coin-flip example\n\nEvery statistics text must contain a coin-flipping example, I'll use it here to get it out of the way. Suppose, naively, that you are unsure about the probability of heads in a coin flip (spoiler alert: it's 50%). You believe there is some true underlying ratio, call it $p$, but have no prior opinion on what $p$ might be. \n\nWe begin to flip a coin, and record the observations: either $H$ or $T$. This is our observed data. An interesting question to ask is how our inference changes as we observe more and more data? More specifically, what do our posterior probabilities look like when we have little data, versus when we have lots of data. \n\nBelow we plot a sequence of updating posterior probabilities as we observe increasing amounts of data (coin flips).\n\n\n```\n\"\"\"\nThe book uses a custom matplotlibrc file, which provides the unique styles for\nmatplotlib plots. If executing this book, and you wish to use the book's\nstyling, provided are two options:\n 1. Overwrite your own matplotlibrc file with the rc-file provided in the\n book's styles/ dir. See http://matplotlib.org/users/customizing.html\n 2. Also in the styles is bmh_matplotlibrc.json file. This can be used to\n update the styles in only this notebook. Try running the following code:\n\n import json\n s = json.load( open(\"../styles/bmh_matplotlibrc.json\") )\n matplotlib.rcParams.update(s)\n\n\"\"\"\n\n# The code below can be passed over, as it is currently not important, plus it\n# uses advanced topics we have not covered yet. LOOK AT PICTURE, MICHAEL!\n%matplotlib inline\nfrom IPython.core.pylabtools import figsize\nimport numpy as np\nfrom matplotlib import pyplot as plt\nfigsize(11, 9)\n\nimport scipy.stats as stats\n\ndist = stats.beta\nn_trials = [0, 1, 2, 3, 4, 5, 8, 15, 50, 500]\ndata = stats.bernoulli.rvs(0.5, size=n_trials[-1])\nx = np.linspace(0, 1, 100)\n\n# For the already prepared, I'm using Binomial's conj. prior.\nfor k, N in enumerate(n_trials):\n sx = plt.subplot(len(n_trials)/2, 2, k+1)\n plt.xlabel(\"$p$, probability of heads\") \\\n if k in [0, len(n_trials)-1] else None\n plt.setp(sx.get_yticklabels(), visible=False)\n heads = data[:N].sum()\n y = dist.pdf(x, 1 + heads, 1 + N - heads)\n plt.plot(x, y, label=\"observe %d tosses,\\n %d heads\" % (N, heads))\n plt.fill_between(x, 0, y, color=\"#348ABD\", alpha=0.4)\n plt.vlines(0.5, 0, 4, color=\"k\", linestyles=\"--\", lw=1)\n\n leg = plt.legend()\n leg.get_frame().set_alpha(0.4)\n plt.autoscale(tight=True)\n\n\nplt.suptitle(\"Bayesian updating of posterior probabilities\",\n y=1.02,\n fontsize=14)\n\nplt.tight_layout()\n```\n\nThe posterior probabilities are represented by the curves, and our uncertainty is proportional to the width of the curve. As the plot above shows, as we start to observe data our posterior probabilities start to shift and move around. Eventually, as we observe more and more data (coin-flips), our probabilities will tighten closer and closer around the true value of $p=0.5$ (marked by a dashed line). \n\nNotice that the plots are not always *peaked* at 0.5. There is no reason it should be: recall we assumed we did not have a prior opinion of what $p$ is. In fact, if we observe quite extreme data, say 8 flips and only 1 observed heads, our distribution would look very biased *away* from lumping around 0.5 (with no prior opinion, how confident would you feel betting on a fair coin after observing 8 tails and 1 head). As more data accumulates, we would see more and more probability being assigned at $p=0.5$, though never all of it.\n\nThe next example is a simple demonstration of the mathematics of Bayesian inference. \n\n##### Example: Bug, or just sweet, unintended feature?\n\n\nLet $A$ denote the event that our code has **no bugs** in it. Let $X$ denote the event that the code passes all debugging tests. For now, we will leave the prior probability of no bugs as a variable, i.e. $P(A) = p$. \n\nWe are interested in $P(A|X)$, i.e. the probability of no bugs, given our debugging tests $X$. To use the formula above, we need to compute some quantities.\n\nWhat is $P(X | A)$, i.e., the probability that the code passes $X$ tests *given* there are no bugs? Well, it is equal to 1, for a code with no bugs will pass all tests. \n\n$P(X)$ is a little bit trickier: The event $X$ can be divided into two possibilities, event $X$ occurring even though our code *indeed has* bugs (denoted $\\sim A\\;$, spoken *not $A$*), or event $X$ without bugs ($A$). $P(X)$ can be represented as:\n\n\\begin{align}\nP(X ) & = P(X \\text{ and } A) + P(X \\text{ and } \\sim A) \\\\\\\\[5pt]\n & = P(X|A)P(A) + P(X | \\sim A)P(\\sim A)\\\\\\\\[5pt]\n& = P(X|A)p + P(X | \\sim A)(1-p)\n\\end{align}\n\nWe have already computed $P(X|A)$ above. On the other hand, $P(X | \\sim A)$ is subjective: our code can pass tests but still have a bug in it, though the probability there is a bug present is reduced. Note this is dependent on the number of tests performed, the degree of complication in the tests, etc. Let's be conservative and assign $P(X|\\sim A) = 0.5$. Then\n\n\\begin{align}\nP(A | X) & = \\frac{1\\cdot p}{ 1\\cdot p +0.5 (1-p) } \\\\\\\\\n& = \\frac{ 2 p}{1+p}\n\\end{align}\nThis is the posterior probability. What does it look like as a function of our prior, $p \\in [0,1]$? \n\n\n```\nfigsize(12.5, 4)\np = np.linspace(0, 1, 50)\nplt.plot(p, 2*p/(1+p), color=\"#348ABD\", lw=3)\n#plt.fill_between(p, 2*p/(1+p), alpha=.5, facecolor=[\"#A60628\"])\nplt.scatter(0.2, 2*(0.2)/1.2, s=140, c=\"#348ABD\")\nplt.xlim(0, 1)\nplt.ylim(0, 1)\nplt.xlabel(\"Prior, $P(A) = p$\")\nplt.ylabel(\"Posterior, $P(A|X)$, with $P(A) = p$\")\nplt.title(\"Are there bugs in my code?\")\n```\n\nWe can see the biggest gains if we observe the $X$ tests passed when the prior probability, $p$, is low. Let's settle on a specific value for the prior. I'm a strong programmer (I think), so I'm going to give myself a realistic prior of 0.20, that is, there is a 20% chance that I write code bug-free. To be more realistic, this prior should be a function of how complicated and large the code is, but let's pin it at 0.20. Then my updated belief that my code is bug-free is 0.33. \n\nRecall that the prior is a probability: $p$ is the prior probability that there *are no bugs*, so $1-p$ is the prior probability that there *are bugs*.\n\nSimilarly, our posterior is also a probability, with $P(A | X)$ the probability there is no bug *given we saw all tests pass*, hence $1-P(A|X)$ is the probability there is a bug *given all tests passed*. What does our posterior probability look like? Below is a chart of both the prior and the posterior probabilities. \n\n\n\n```\nfigsize(12.5, 4)\ncolours = [\"#348ABD\", \"#A60628\"]\n\nprior = [0.20, 0.80]\nposterior = [1./3, 2./3]\nplt.bar([0, .7], prior, alpha=0.70, width=0.25,\n color=colours[0], label=\"prior distribution\",\n lw=\"3\", edgecolor=colours[0])\n\nplt.bar([0+0.25, .7+0.25], posterior, alpha=0.7,\n width=0.25, color=colours[1],\n label=\"posterior distribution\",\n lw=\"3\", edgecolor=colours[1])\n\nplt.xticks([0.20, .95], [\"Bugs Absent\", \"Bugs Present\"])\nplt.title(\"Prior and Posterior probability of bugs present\")\nplt.ylabel(\"Probability\")\nplt.legend(loc=\"upper left\");\n```\n\nNotice that after we observed $X$ occur, the probability of bugs being absent increased. By increasing the number of tests, we can approach confidence (probability 1) that there are no bugs present.\n\nThis was a very simple example of Bayesian inference and Bayes rule. Unfortunately, the mathematics necessary to perform more complicated Bayesian inference only becomes more difficult, except for artificially constructed cases. We will later see that this type of mathematical analysis is actually unnecessary. First we must broaden our modeling tools. The next section deals with *probability distributions*. If you are already familiar, feel free to skip (or at least skim), but for the less familiar the next section is essential.\n\n_______\n\n##Probability Distributions\n\n\n**Let's quickly recall what a probability distribution is:** Let $Z$ be some random variable. Then associated with $Z$ is a *probability distribution function* that assigns probabilities to the different outcomes $Z$ can take. Graphically, a probability distribution is a curve where the probability of an outcome is proportional to the height of the curve. You can see examples in the first figure of this chapter. \n\nWe can divide random variables into three classifications:\n\n- **$Z$ is discrete**: Discrete random variables may only assume values on a specified list. Things like populations, movie ratings, and number of votes are all discrete random variables. Discrete random variables become more clear when we contrast them with...\n\n- **$Z$ is continuous**: Continuous random variable can take on arbitrarily exact values. For example, temperature, speed, time, color are all modeled as continuous variables because you can progressively make the values more and more precise.\n\n- **$Z$ is mixed**: Mixed random variables assign probabilities to both discrete and continuous random variables, i.e. it is a combination of the above two categories. \n\n###Discrete Case\nIf $Z$ is discrete, then its distribution is called a *probability mass function*, which measures the probability $Z$ takes on the value $k$, denoted $P(Z=k)$. Note that the probability mass function completely describes the random variable $Z$, that is, if we know the mass function, we know how $Z$ should behave. There are popular probability mass functions that consistently appear: we will introduce them as needed, but let's introduce the first very useful probability mass function. We say $Z$ is *Poisson*-distributed if:\n\n$$P(Z = k) =\\frac{ \\lambda^k e^{-\\lambda} }{k!}, \\; \\; k=0,1,2, \\dots $$\n\n$\\lambda$ is called a parameter of the distribution, and it controls the distribution's shape. For the Poisson distribution, $\\lambda$ can be any positive number. By increasing $\\lambda$, we add more probability to larger values, and conversely by decreasing $\\lambda$ we add more probability to smaller values. One can describe $\\lambda$ as the *intensity* of the Poisson distribution. \n\nUnlike $\\lambda$, which can be any positive number, the value $k$ in the above formula must be a non-negative integer, i.e., $k$ must take on values 0,1,2, and so on. This is very important, because if you wanted to model a population you could not make sense of populations with 4.25 or 5.612 members. \n\nIf a random variable $Z$ has a Poisson mass distribution, we denote this by writing\n\n$$Z \\sim \\text{Poi}(\\lambda) $$\n\nOne useful property of the Poisson distribution is that its expected value is equal to its parameter, i.e.:\n\n$$E\\large[ \\;Z\\; | \\; \\lambda \\;\\large] = \\lambda $$\n\nWe will use this property often, so it's useful to remember. Below, we plot the probability mass distribution for different $\\lambda$ values. The first thing to notice is that by increasing $\\lambda$, we add more probability of larger values occurring. Second, notice that although the graph ends at 15, the distributions do not. They assign positive probability to every non-negative integer.\n\n\n```\nfigsize(12.5, 4)\n\nimport scipy.stats as stats\na = np.arange(16)\npoi = stats.poisson\nlambda_ = [1.5, 4.25]\ncolours = [\"#348ABD\", \"#A60628\"]\n\nplt.bar(a, poi.pmf(a, lambda_[0]), color=colours[0],\n label=\"$\\lambda = %.1f$\" % lambda_[0], alpha=0.60,\n edgecolor=colours[0], lw=\"3\")\n\nplt.bar(a, poi.pmf(a, lambda_[1]), color=colours[1],\n label=\"$\\lambda = %.1f$\" % lambda_[1], alpha=0.60,\n edgecolor=colours[1], lw=\"3\")\n\nplt.xticks(a + 0.4, a)\nplt.legend()\nplt.ylabel(\"probability of $k$\")\nplt.xlabel(\"$k$\")\nplt.title(\"Probability mass function of a Poisson random variable; differing \\\n$\\lambda$ values\")\n```\n\n###Continuous Case\nInstead of a probability mass function, a continuous random variable has a *probability density function*. This might seem like unnecessary nomenclature, but the density function and the mass function are very different creatures. An example of continuous random variable is a random variable with *exponential density*. The density function for an exponential random variable looks like this:\n\n$$f_Z(z | \\lambda) = \\lambda e^{-\\lambda z }, \\;\\; z\\ge 0$$\n\nLike a Poisson random variable, an exponential random variable can take on only non-negative values. But unlike a Poisson variable, the exponential can take on *any* non-negative values, including non-integral values such as 4.25 or 5.612401. This property makes it a poor choice for count data, which must be an integer, but a great choice for time data, temperature data (measured in Kelvins, of course), or any other precise *and positive* variable. The graph below shows two probability density functions with different $\\lambda$ values. \n\nWhen a random variable $Z$ has an exponential distribution with parameter $\\lambda$, we say *$Z$ is exponential* and write\n\n$$Z \\sim \\text{Exp}(\\lambda)$$\n\nGiven a specific $\\lambda$, the expected value of an exponential random variable is equal to the inverse of $\\lambda$, that is:\n\n$$E[\\; Z \\;|\\; \\lambda \\;] = \\frac{1}{\\lambda}$$\n\n\n```\na = np.linspace(0, 4, 100)\nexpo = stats.expon\nlambda_ = [0.5, 1]\n\nfor l, c in zip(lambda_, colours):\n plt.plot(a, expo.pdf(a, scale=1./l), lw=3,\n color=c, label=\"$\\lambda = %.1f$\" % l)\n plt.fill_between(a, expo.pdf(a, scale=1./l), color=c, alpha=.33)\n\nplt.legend()\nplt.ylabel(\"PDF at $z$\")\nplt.xlabel(\"$z$\")\nplt.ylim(0,1.2)\nplt.title(\"Probability density function of an Exponential random variable;\\\n differing $\\lambda$\");\n```\n\n\n###But what is $\\lambda \\;$?\n\n\n**This question is what motivates statistics**. In the real world, $\\lambda$ is hidden from us. We see only $Z$, and must go backwards to try and determine $\\lambda$. The problem is difficult because there is no one-to-one mapping from $Z$ to $\\lambda$. Many different methods have been created to solve the problem of estimating $\\lambda$, but since $\\lambda$ is never actually observed, no one can say for certain which method is best! \n\nBayesian inference is concerned with *beliefs* about what $\\lambda$ might be. Rather than try to guess $\\lambda$ exactly, we can only talk about what $\\lambda$ is likely to be by assigning a probability distribution to $\\lambda$.\n\nThis might seem odd at first. After all, $\\lambda$ is fixed; it is not (necessarily) random! How can we assign probabilities to values of a non-random variable? Ah, we have fallen for our old, frequentist way of thinking. Recall that under Bayesian philosophy, we *can* assign probabilities if we interpret them as beliefs. And it is entirely acceptable to have *beliefs* about the parameter $\\lambda$. \n\n\n\n##### Example: Inferring behaviour from text-message data\n\nLet's try to model a more interesting example, one that concerns the rate at which a user sends and receives text messages:\n\n> You are given a series of daily text-message counts from a user of your system. The data, plotted over time, appears in the chart below. You are curious to know if the user's text-messaging habits have changed over time, either gradually or suddenly. How can you model this? (This is in fact my own text-message data. Judge my popularity as you wish.)\n\n\n\n```\nfigsize(12.5, 3.5)\ncount_data = np.loadtxt(\"data/txtdata.csv\")\nn_count_data = len(count_data)\nplt.bar(np.arange(n_count_data), count_data, color=\"#348ABD\")\nplt.xlabel(\"Time (days)\")\nplt.ylabel(\"count of text-msgs received\")\nplt.title(\"Did the user's texting habits change over time?\")\nplt.xlim(0, n_count_data);\n```\n\nBefore we start modeling, see what you can figure out just by looking at the chart above. Would you say there was a change in behaviour during this time period? \n\nHow can we start to model this? Well, as we have conveniently already seen, a Poisson random variable is a very appropriate model for this type of *count* data. Denoting day $i$'s text-message count by $C_i$, \n\n$$ C_i \\sim \\text{Poisson}(\\lambda) $$\n\nWe are not sure what the value of the $\\lambda$ parameter really is, however. Looking at the chart above, it appears that the rate might become higher late in the observation period, which is equivalent to saying that $\\lambda$ increases at some point during the observations. (Recall that a higher value of $\\lambda$ assigns more probability to larger outcomes. That is, there is a higher probability of many text messages having been sent on a given day.)\n\nHow can we represent this observation mathematically? Let's assume that on some day during the observation period (call it $\\tau$), the parameter $\\lambda$ suddenly jumps to a higher value. So we really have two $\\lambda$ parameters: one for the period before $\\tau$, and one for the rest of the observation period. In the literature, a sudden transition like this would be called a *switchpoint*:\n\n$$\n\\lambda = \n\\begin{cases}\n\\lambda_1 & \\text{if } t \\lt \\tau \\cr\n\\lambda_2 & \\text{if } t \\ge \\tau\n\\end{cases}\n$$\n\n\nIf, in reality, no sudden change occurred and indeed $\\lambda_1 = \\lambda_2$, then the $\\lambda$s posterior distributions should look about equal.\n\nWe are interested in inferring the unknown $\\lambda$s. To use Bayesian inference, we need to assign prior probabilities to the different possible values of $\\lambda$. What would be good prior probability distributions for $\\lambda_1$ and $\\lambda_2$? Recall that $\\lambda$ can be any positive number. As we saw earlier, the *exponential* distribution provides a continuous density function for positive numbers, so it might be a good choice for modeling $\\lambda_i$. But recall that the exponential distribution takes a parameter of its own, so we'll need to include that parameter in our model. Let's call that parameter $\\alpha$.\n\n\\begin{align}\n&\\lambda_1 \\sim \\text{Exp}( \\alpha ) \\\\\\\n&\\lambda_2 \\sim \\text{Exp}( \\alpha )\n\\end{align}\n\n$\\alpha$ is called a *hyper-parameter* or *parent variable*. In literal terms, it is a parameter that influences other parameters. Our initial guess at $\\alpha$ does not influence the model too strongly, so we have some flexibility in our choice. A good rule of thumb is to set the exponential parameter equal to the inverse of the average of the count data. Since we're modeling $\\lambda$ using an exponential distribution, we can use the expected value identity shown earlier to get:\n\n$$\\frac{1}{N}\\sum_{i=0}^N \\;C_i \\approx E[\\; \\lambda \\; |\\; \\alpha ] = \\frac{1}{\\alpha}$$ \n\nAn alternative, and something I encourage the reader to try, would be to have two priors: one for each $\\lambda_i$. Creating two exponential distributions with different $\\alpha$ values reflects our prior belief that the rate changed at some point during the observations.\n\nWhat about $\\tau$? Because of the noisiness of the data, it's difficult to pick out a priori when $\\tau$ might have occurred. Instead, we can assign a *uniform prior belief* to every possible day. This is equivalent to saying\n\n\\begin{align}\n& \\tau \\sim \\text{DiscreteUniform(1,70) }\\\\\\\\\n& \\Rightarrow P( \\tau = k ) = \\frac{1}{70}\n\\end{align}\n\nSo after all this, what does our overall prior distribution for the unknown variables look like? Frankly, *it doesn't matter*. What we should understand is that it's an ugly, complicated mess involving symbols only a mathematician could love. And things will only get uglier the more complicated our models become. Regardless, all we really care about is the posterior distribution.\n\nWe next turn to PyMC, a Python library for performing Bayesian analysis that is undaunted by the mathematical monster we have created. \n\n\nIntroducing our first hammer: PyMC\n-----\n\nPyMC is a Python library for programming Bayesian analysis [3]. It is a fast, well-maintained library. The only unfortunate part is that its documentation is lacking in certain areas, especially those that bridge the gap between beginner and hacker. One of this book's main goals is to solve that problem, and also to demonstrate why PyMC is so cool.\n\nWe will model the problem above using PyMC. This type of programming is called *probabilistic programming*, an unfortunate misnomer that invokes ideas of randomly-generated code and has likely confused and frightened users away from this field. The code is not random; it is probabilistic in the sense that we create probability models using programming variables as the model's components. Model components are first-class primitives within the PyMC framework. \n\nB. Cronin [5] has a very motivating description of probabilistic programming:\n\n> Another way of thinking about this: unlike a traditional program, which only runs in the forward directions, a probabilistic program is run in both the forward and backward direction. It runs forward to compute the consequences of the assumptions it contains about the world (i.e., the model space it represents), but it also runs backward from the data to constrain the possible explanations. In practice, many probabilistic programming systems will cleverly interleave these forward and backward operations to efficiently home in on the best explanations.\n\nBecause of the confusion engendered by the term *probabilistic programming*, I'll refrain from using it. Instead, I'll simply say *programming*, since that's what it really is. \n\nPyMC code is easy to read. The only novel thing should be the syntax, and I will interrupt the code to explain individual sections. Simply remember that we are representing the model's components ($\\tau, \\lambda_1, \\lambda_2$ ) as variables:\n\n\n```\nimport pymc as pm\n\nalpha = 1.0/count_data.mean() # Recall count_data is the\n # variable that holds our txt counts\nlambda_1 = pm.Exponential(\"lambda_1\", alpha)\nlambda_2 = pm.Exponential(\"lambda_2\", alpha)\n\ntau = pm.DiscreteUniform(\"tau\", lower=0, upper=n_count_data)\n```\n\nIn the code above, we create the PyMC variables corresponding to $\\lambda_1$ and $\\lambda_2$. We assign them to PyMC's *stochastic variables*, so-called because they are treated by the back end as random number generators. We can demonstrate this fact by calling their built-in `random()` methods.\n\n\n```\nprint \"Random output:\", tau.random(), tau.random(), tau.random()\n```\n\n Random output: 39 10 32\n\n\n\n```\n@pm.deterministic\ndef lambda_(tau=tau, lambda_1=lambda_1, lambda_2=lambda_2):\n out = np.zeros(n_count_data)\n out[:tau] = lambda_1 # lambda before tau is lambda1\n out[tau:] = lambda_2 # lambda after (and including) tau is lambda2\n return out\n```\n\nThis code creates a new function `lambda_`, but really we can think of it as a random variable: the random variable $\\lambda$ from above. Note that because `lambda_1`, `lambda_2` and `tau` are random, `lambda_` will be random. We are **not** fixing any variables yet.\n\n`@pm.deterministic` is a decorator that tells PyMC this is a deterministic function. That is, if the arguments were deterministic (which they are not), the output would be deterministic as well. \n\n\n```\nobservation = pm.Poisson(\"obs\", lambda_, value=count_data, observed=True)\n\nmodel = pm.Model([observation, lambda_1, lambda_2, tau])\n```\n\nThe variable `observation` combines our data, `count_data`, with our proposed data-generation scheme, given by the variable `lambda_`, through the `value` keyword. We also set `observed = True` to tell PyMC that this should stay fixed in our analysis. Finally, PyMC wants us to collect all the variables of interest and create a `Model` instance out of them. This makes our life easier when we retrieve the results.\n\nThe code below will be explained in Chapter 3, but I show it here so you can see where our results come from. One can think of it as a *learning* step. The machinery being employed is called *Markov Chain Monte Carlo* (MCMC), which I also delay explaining until Chapter 3. This technique returns thousands of random variables from the posterior distributions of $\\lambda_1, \\lambda_2$ and $\\tau$. We can plot a histogram of the random variables to see what the posterior distributions look like. Below, we collect the samples (called *traces* in the MCMC literature) into histograms.\n\n\n```\n### Mysterious code to be explained in Chapter 3.\nmcmc = pm.MCMC(model)\nmcmc.sample(40000, 10000, 1)\n```\n\n [****************100%******************] 40000 of 40000 complete\n\n\n\n```\nlambda_1_samples = mcmc.trace('lambda_1')[:]\nlambda_2_samples = mcmc.trace('lambda_2')[:]\ntau_samples = mcmc.trace('tau')[:]\n```\n\n\n```\nfigsize(12.5, 10)\n#histogram of the samples:\n\nax = plt.subplot(311)\nax.set_autoscaley_on(False)\n\nplt.hist(lambda_1_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_1$\", color=\"#A60628\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.title(r\"\"\"Posterior distributions of the variables\n $\\lambda_1,\\;\\lambda_2,\\;\\tau$\"\"\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_1$ value\")\n\nax = plt.subplot(312)\nax.set_autoscaley_on(False)\nplt.hist(lambda_2_samples, histtype='stepfilled', bins=30, alpha=0.85,\n label=\"posterior of $\\lambda_2$\", color=\"#7A68A6\", normed=True)\nplt.legend(loc=\"upper left\")\nplt.xlim([15, 30])\nplt.xlabel(\"$\\lambda_2$ value\")\n\nplt.subplot(313)\nw = 1.0 / tau_samples.shape[0] * np.ones_like(tau_samples)\nplt.hist(tau_samples, bins=n_count_data, alpha=1,\n label=r\"posterior of $\\tau$\",\n color=\"#467821\", weights=w, rwidth=2.)\nplt.xticks(np.arange(n_count_data))\n\nplt.legend(loc=\"upper left\")\nplt.ylim([0, .75])\nplt.xlim([35, len(count_data)-20])\nplt.xlabel(r\"$\\tau$ (in days)\")\nplt.ylabel(\"probability\");\n```\n\n### Interpretation\n\nRecall that Bayesian methodology returns a *distribution*. Hence we now have distributions to describe the unknown $\\lambda$s and $\\tau$. What have we gained? Immediately, we can see the uncertainty in our estimates: the wider the distribution, the less certain our posterior belief should be. We can also see what the plausible values for the parameters are: $\\lambda_1$ is around 18 and $\\lambda_2$ is around 23. The posterior distributions of the two $\\lambda$s are clearly distinct, indicating that it is indeed likely that there was a change in the user's text-message behaviour.\n\nWhat other observations can you make? If you look at the original data again, do these results seem reasonable? \n\nNotice also that the posterior distributions for the $\\lambda$s do not look like exponential distributions, even though our priors for these variables were exponential. In fact, the posterior distributions are not really of any form that we recognize from the original model. But that's OK! This is one of the benefits of taking a computational point of view. If we had instead done this analysis using mathematical approaches, we would have been stuck with an analytically intractable (and messy) distribution. Our use of a computational approach makes us indifferent to mathematical tractability.\n\nOur analysis also returned a distribution for $\\tau$. Its posterior distribution looks a little different from the other two because it is a discrete random variable, so it doesn't assign probabilities to intervals. We can see that near day 45, there was a 50% chance that the user's behaviour changed. Had no change occurred, or had the change been gradual over time, the posterior distribution of $\\tau$ would have been more spread out, reflecting that many days were plausible candidates for $\\tau$. By contrast, in the actual results we see that only three or four days make any sense as potential transition points. \n\n###Why would I want samples from the posterior, anyways?\n\n\nWe will deal with this question for the remainder of the book, and it is an understatement to say that it will lead us to some amazing results. For now, let's end this chapter with one more example.\n\nWe'll use the posterior samples to answer the following question: what is the expected number of texts at day $t, \\; 0 \\le t \\le 70$ ? Recall that the expected value of a Poisson variable is equal to its parameter $\\lambda$. Therefore, the question is equivalent to *what is the expected value of $\\lambda$ at time $t$*?\n\nIn the code below, let $i$ index samples from the posterior distributions. Given a day $t$, we average over all possible $\\lambda_i$ for that day $t$, using $\\lambda_i = \\lambda_{1,i}$ if $t \\lt \\tau_i$ (that is, if the behaviour change has not yet occurred), else we use $\\lambda_i = \\lambda_{2,i}$. \n\n\n```\nfigsize(12.5, 5)\n# tau_samples, lambda_1_samples, lambda_2_samples contain\n# N samples from the corresponding posterior distribution\nN = tau_samples.shape[0]\nexpected_texts_per_day = np.zeros(n_count_data)\nfor day in range(0, n_count_data):\n # ix is a bool index of all tau samples corresponding to\n # the switchpoint occurring prior to value of 'day'\n ix = day < tau_samples\n # Each posterior sample corresponds to a value for tau.\n # for each day, that value of tau indicates whether we're \"before\"\n # (in the lambda1 \"regime\") or\n # \"after\" (in the lambda2 \"regime\") the switchpoint.\n # by taking the posterior sample of lambda1/2 accordingly, we can average\n # over all samples to get an expected value for lambda on that day.\n # As explained, the \"message count\" random variable is Poisson distributed,\n # and therefore lambda (the poisson parameter) is the expected value of\n # \"message count\".\n expected_texts_per_day[day] = (lambda_1_samples[ix].sum()\n + lambda_2_samples[~ix].sum()) / N\n\n\nplt.plot(range(n_count_data), expected_texts_per_day, lw=4, color=\"#E24A33\",\n label=\"expected number of text-messages received\")\nplt.xlim(0, n_count_data)\nplt.xlabel(\"Day\")\nplt.ylabel(\"Expected # text-messages\")\nplt.title(\"Expected number of text-messages received\")\nplt.ylim(0, 60)\nplt.bar(np.arange(len(count_data)), count_data, color=\"#348ABD\", alpha=0.65,\n label=\"observed texts per day\")\n\nplt.legend(loc=\"upper left\");\n```\n\nOur analysis shows strong support for believing the user's behavior did change ($\\lambda_1$ would have been close in value to $\\lambda_2$ had this not been true), and that the change was sudden rather than gradual (as demonstrated by $\\tau$'s strongly peaked posterior distribution). We can speculate what might have caused this: a cheaper text-message rate, a recent weather-to-text subscription, or perhaps a new relationship. (In fact, the 45th day corresponds to Christmas, and I moved away to Toronto the next month, leaving a girlfriend behind.)\n\n\n##### Exercises\n\n1\\. Using `lambda_1_samples` and `lambda_2_samples`, what is the mean of the posterior distributions of $\\lambda_1$ and $\\lambda_2$?\n\n\n```\n#type your code here.\n```\n\n2\\. What is the expected percentage increase in text-message rates? `hint:` compute the mean of `lambda_1_samples/lambda_2_samples`. Note that this quantity is very different from `lambda_1_samples.mean()/lambda_2_samples.mean()`.\n\n\n```\n#type your code here.\n```\n\n3\\. What is the mean of $\\lambda_1$ **given** that we know $\\tau$ is less than 45. That is, suppose we have been given new information that the change in behaviour occurred prior to day 45. What is the expected value of $\\lambda_1$ now? (You do not need to redo the PyMC part. Just consider all instances where `tau_samples < 45`.)\n\n\n```\n#type your code here.\n```\n\n### References\n\n\n- [1] Gelman, Andrew. N.p.. Web. 22 Jan 2013. [N is never large enough](http://andrewgelman.com/2005/07/n_is_never_large).\n- [2] Norvig, Peter. 2009. [The Unreasonable Effectiveness of Data](http://static.googleusercontent.com/media/research.google.com/en//pubs/archive/35179.pdf).\n- [3] Patil, A., D. Huard and C.J. Fonnesbeck. 2010. \nPyMC: Bayesian Stochastic Modelling in Python. Journal of Statistical \nSoftware, 35(4), pp. 1-81. \n- [4] Jimmy Lin and Alek Kolcz. Large-Scale Machine Learning at Twitter. Proceedings of the 2012 ACM SIGMOD International Conference on Management of Data (SIGMOD 2012), pages 793-804, May 2012, Scottsdale, Arizona.\n- [5] Cronin, Beau. \"Why Probabilistic Programming Matters.\" 24 Mar 2013. Google, Online Posting to Google . Web. 24 Mar. 2013. .\n\n\n```\nfrom IPython.core.display import HTML\ndef css_styling():\n styles = open(\"../styles/custom.css\", \"r\").read()\n return HTML(styles)\ncss_styling()\n```\n\n\n\n\n\n\n\n\n\n\n```\n\n```\n", "meta": {"hexsha": "200485437869b0add671eb5f2422e64aab16cb80", "size": 413239, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Chapter1_Introduction/Chapter1_Introduction.ipynb", "max_stars_repo_name": "finderabd135/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_stars_repo_head_hexsha": "a423eda8538ed0b51cccd7b10e70b1404cfba8e4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2019-04-09T19:44:20.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-09T19:44:20.000Z", "max_issues_repo_path": "Chapter1_Introduction/Chapter1_Introduction.ipynb", "max_issues_repo_name": "finderabd135/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_issues_repo_head_hexsha": "a423eda8538ed0b51cccd7b10e70b1404cfba8e4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chapter1_Introduction/Chapter1_Introduction.ipynb", "max_forks_repo_name": "finderabd135/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers", "max_forks_repo_head_hexsha": "a423eda8538ed0b51cccd7b10e70b1404cfba8e4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 386.9279026217, "max_line_length": 110815, "alphanum_fraction": 0.9045177246, "converted": true, "num_tokens": 11151, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2877678157610531, "lm_q2_score": 0.36658973632215985, "lm_q1q2_score": 0.10549272770184832}}
{"text": "\n\n## Data-driven Design and Analyses of Structures and Materials (3dasm)\n\n## Lecture 13\n\n### Miguel A. Bessa | M.A.Bessa@tudelft.nl | Associate Professor\n\n**What:** A lecture of the \"3dasm\" course\n\n**Where:** This notebook comes from this [repository](https://github.com/bessagroup/3dasm_course)\n\n**Reference for entire course:** Murphy, Kevin P. *Probabilistic machine learning: an introduction*. MIT press, 2022. Available online [here](https://probml.github.io/pml-book/book1.html)\n\n**How:** We try to follow Murphy's book closely, but the sequence of Chapters and Sections is different. The intention is to use notebooks as an introduction to the topic and Murphy's book as a resource.\n* If working offline: Go through this notebook and read the book.\n* If attending class in person: listen to me (!) but also go through the notebook in your laptop at the same time. Read the book.\n* If attending lectures remotely: listen to me (!) via Zoom and (ideally) use two screens where you have the notebook open in 1 screen and you see the lectures on the other. Read the book.\n\n**Optional reference (the \"bible\" by the \"bishop\"... pun intended 😆) :** Bishop, Christopher M. *Pattern recognition and machine learning*. Springer Verlag, 2006.\n\n**References/resources to create this notebook:**\n* Chapter 11 of Murphy's book.\n\nApologies in advance if I missed some reference used in this notebook. Please contact me if that is the case, and I will gladly include it here.\n\n## **OPTION 1**. Run this notebook **locally in your computer**:\n1. Confirm that you have the 3dasm conda environment (see Lecture 1).\n\n2. Go to the 3dasm_course folder in your computer and pull the last updates of the [repository](https://github.com/bessagroup/3dasm_course):\n```\ngit pull\n```\n3. Open command window and load jupyter notebook (it will open in your internet browser):\n```\nconda activate 3dasm\njupyter notebook\n```\n4. Open notebook of this Lecture.\n\n## **OPTION 2**. Use **Google's Colab** (no installation required, but times out if idle):\n\n1. go to https://colab.research.google.com\n2. login\n3. File > Open notebook\n4. click on Github (no need to login or authorize anything)\n5. paste the git link: https://github.com/bessagroup/3dasm_course\n6. click search and then click on the notebook for this Lecture.\n\n\n```python\n# Basic plotting tools needed in Python.\n\nimport matplotlib.pyplot as plt # import plotting tools to create figures\nimport numpy as np # import numpy to handle a lot of things!\nfrom IPython.display import display, Math # to print with Latex math\n\n%config InlineBackend.figure_format = \"retina\" # render higher resolution images in the notebook\n#plt.style.use(\"seaborn\") # style for plotting that comes from seaborn\nplt.rcParams[\"figure.figsize\"] = (8,4) # rescale figure size appropriately for slides\n```\n\n## Outline for today\n\n* Derivation of different Linear Regression models\n - Picking up where we left off in Lecture 8.\n\n**Reading material**: This notebook + Chapter 11 of the book.\n\n## Recap of Lectures 8 and 9\n\nRecall our view of Linear regression models from a Bayesian perspective: it's all about the choice of **likelihood** and **prior**!\n\n| Likelihood | Prior (on the weights) | Posterior | Name of the model | Book section |\n|--- |--- |--- |--- |--- |\n| Gaussian | Uniform | Point estimate | Least Squares regression | 11.2.2 |\n| Gaussian | Gaussian | Point estimate | Ridge regression | 11.3 |\n| Gaussian | Laplace | Point estimate | Lasso regression | 11.4 |\n| Student-$t$ | Uniform | Point estimate | Robust regression | 11.6.1 |\n| Laplace | Uniform | Point estimate | Robust regression | 11.6.2 |\n| Gaussian | Gaussian | Gaussian | Bayesian linear regression | 11.7 |\n\nLet's continue along the lines of the Homework of Lecture 8, and derive a few of these models for the multidimensional case.\n\nWe are now totally prepared to derive any ML model in any dimension!\n\nIn Lecture 8 and its Homework we derived linear regression models using 1D input $x$, 1D output $y$, and a polynomial basis function $\\boldsymbol{\\phi}(x)$.\n\nWe will quickly recap what we did then, and then show how this generalizes to multidimensional inputs $\\mathbf{x}$ and for any kind of basis function $\\boldsymbol{\\phi}(\\mathbf{x})$.\n\n* Note: without loss of generality, we will keep considering a single output $y$.\n\n## Linear Least Squares: Linear regression with Gaussian likelihood, Uniform prior and posterior via Point estimate\n\n| Likelihood | Prior (on the weights) | Posterior | Name of the model | Book section |\n|--- |--- |--- |--- |--- |\n| Gaussian | Uniform | Point estimate | Least Squares regression | 11.2.2 |\n\nThis model assumes a Gaussian observation distribution with constant variance and \"linear\" mean (recall: linear in the unknowns $\\mathbf{z}$). If considering 1D input $x$ and 1D output $y$ the model is written as:\n1. Gaussian observation distribution: $p(y|x, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(x), \\sigma_{y|z}^2 = \\sigma^2)$\n\nwhere $\\mathbf{z} = (\\mathbf{w}, \\sigma)$ are all the unknown model parameters (hidden rv's).\n\n2. Uniform prior distribution for each hidden rv in $\\mathbf{z}$: $p(\\mathbf{z}) \\propto 1$\n\n3. MLE point estimate for posterior: $\\hat{\\mathbf{z}}_{\\text{mle}} = \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{i=1}^{N}\\log{ p(y=y_i|x=x_i, \\mathbf{z})}\\right]$\n\nFinal prediction is given by the PPD : $\\require{color}\n{\\color{orange}p(y|x, \\mathcal{D})} = \\int p(y|x,\\mathbf{z}) \\delta(\\mathbf{z}-\\hat{\\mathbf{z}}) dz = p(y|x, \\mathbf{z}=\\hat{\\mathbf{z}})$\n\n#### Notes\n\nCompared to the previous lectures, pay attention to the following updates in the notation of our 1D linear regression model:\n\n1. We are explicitly including the input $x$ in the probability densities, as we will no longer fix $x$ to a particular value like we did up to now\n\n2. We are now considering more than one unknown rv and grouping them in the vector $\\mathbf{z}$.\n\n### Recall the car stopping distance problem\n\n\n\nLet's focus (again) on our favorite problem, but now we will not keep the velocity of the car $x$ fixed.\n\nIf we knew the \"ground truth\" of this problem, then it would be given by:\n\n$\\require{color}y = {\\color{red}z_1}\\cdot x + {\\color{red}z_2}\\cdot x^2$\n\n- $y$ is the **output**: the car stopping distance (in meters)\n- ${\\color{red}z_1}$ is a hidden variable: an rv representing the driver's reaction time (in seconds)\n- ${\\color{red}z_2}$ is another hidden variable: an rv that depends on the coefficient of friction, the inclination of the road, the weather, etc. (in m$^{-1}$s$^{-2}$).\n- $x$ is the **input**: constant car velocity (in m/s).\n\nwhere $z_1 \\sim \\mathcal{N}(\\mu_{z_1}=1.5,\\sigma_{z_1}^2=0.5^2)$, and $z_2 \\sim \\mathcal{N}(\\mu_{z_2}=0.1,\\sigma_{z_2}^2=0.01^2)$.\n\nUnsurprisingly, in Exercise 1 of Lecture 9 we saw that a linear model with a **quadratic polynomial basis function** predicts the stopping distance for this problem very well:\n\n1. Gaussian observation distribution: $p(y|x, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(x), \\sigma_{y|z}^2 = \\sigma^2)$\n\nwhere $\\mathbf{z} = (\\mathbf{w}, \\sigma)$ are all the hidden rv's of the model, i.e. the model parameters.\n* the vector $\\mathbf{w} = [w_0, w_1, w_2 ..., w_{M-1}]^T$ includes the **bias** term $w_0$ and the remaining **weights** $w_m$ with $m=0,..., M-1$.\n* the vector $\\boldsymbol{\\phi}(x) = [1, x, x^2, ..., x^{M-1}]^T$ includes the **basis functions**, which now correspond to a polynomial of degree $M-1$. When $M=3$ we have a quadratic polynomial basis (3 unknowns).\n\n2. Uniform prior distribution for each hidden rv in $\\mathbf{z}$: $p(\\mathbf{z}) \\propto 1$\n\n3. MLE point estimate for posterior: $\\hat{\\mathbf{z}}_{\\text{mle}} = \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{n=1}^{N}\\log{ p(y=y_n|x_n, \\mathbf{z})}\\right]$\n\nFor other problems, the polynomial degree $M-1$ of the basis functions may need to be different.\n\n* For example, also in Lecture 9 we saw that for a problem whose ground truth is $x\\sin{x}$ then the polynomial basis function needs to have a higher degree. However, even then the approximation is not brilliant because the ground truth is not really a polynomial!\n\nThere are other basis functions that can be adopted. For example, spline basis functions (Section 11.5 in the book), among many other possibilities (kernels!).\n\nAs we also mentioned, as long as the basis functions $\\boldsymbol{\\phi}(x)$ do not depend on any rv $\\mathbf{z}$ and the mean of observation distribution is defined linearly as a function of the rv's, then we still have a linear regression model.\n\nBut now let's consider problems that still have only one output $y$ but that can have multiple inputs $\\mathbf{x} = [x_1, x_2, ..., x_D]^T$ where $x_d$ is feature $d$ and where $d=1, ..., D$.\n\nIn this case, we can write the multidimensional linear regression model as:\n\n1. Gaussian observation distribution: $p(y|\\mathbf{x}, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}), \\sigma_{y|z}^2 = \\sigma^2)$\n\nwhere $\\mathbf{z} = (\\mathbf{w}, \\sigma)$ are all the hidden rv's of the model, i.e. the model parameters.\n* the vector $\\mathbf{w} = [w_0, w_1, w_2 ..., w_{M-1}]^T$ includes the **bias** term $w_0$ and the remaining **weights** $w_m$ with $m=0,..., M-1$.\n* and the basis functions remain a vector but where each element also acts on a vector $\\mathbf{x}$, where $x_d$ has $D$ features: $\\boldsymbol{\\phi}(\\mathbf{x}) = [\\phi_0(\\mathbf{x}), \\phi_1(\\mathbf{x}), \\phi_2(\\mathbf{x}) ..., \\phi_{M-1}(\\mathbf{x})]^T$\n\nand where the remaining choices for the linear regression model remain the same:\n\n2. Uniform prior distribution for each hidden rv in $\\mathbf{z}$: $p(\\mathbf{z}) \\propto 1$\n\n3. MLE point estimate for posterior: $\\hat{\\mathbf{z}}_{\\text{mle}} = \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{n=1}^{N}\\log{ p(y=y_n|\\mathbf{x} = \\mathbf{x}_n, \\mathbf{z})}\\right]$\n\nFinal prediction is given by the PPD : \n\n$$\\require{color}\n{\\color{orange}p(y|x, \\mathcal{D})} = \\int p(y|x,\\mathbf{z}) \\delta(\\mathbf{z}-\\hat{\\mathbf{z}}) dz = p(y|x, \\mathbf{z}=\\hat{\\mathbf{z}})$$\n\nTherefore, we are capable of predicting the PPD by discovering the unknowns $\\mathbf{z}$ via the point estimate of the posterior, which requires solving the $\\mathrm{argmin}$ of the negative log likelihood.\n\nNow, let's focus on estimating the unknowns $\\mathbf{z}$ via the MLE point estimate of the posterior (maximum likelihood estimation).\n\nAs we saw in Lecture 8, finding the MLE is the same as finding the location of the minimum of the negative log likelihood.\n\nSince our observation distribution is a multivariate Gaussian,\n\n$p(y|x, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}), \\sigma_{y|z}^2 = \\sigma^2)$\n\nthen the likelihood is given by (Lecture 5 but now with vectors):\n\n$$\n\\begin{align}\np(y=\\mathcal{D}_y | \\mathbf{x}=\\mathcal{D}_x, \\mathbf{z}) &= \\prod_{n=1}^{N} p(y=y_n|\\mathbf{x}=\\mathbf{x}_n, \\mathbf{z}) \\\\\n&= p(y=y_1|\\mathbf{x}=\\mathbf{x}_1, \\mathbf{z})p(y=y_2|\\mathbf{x}=\\mathbf{x}_2, \\mathbf{z}) \\cdots p(y=y_N|\\mathbf{x}=\\mathbf{x}_N, \\mathbf{z})\n\\end{align}\n$$\n\nwhich we already know that is also a multivariate Gaussian (unnormalized).\n\nBut, since we are not going fully Bayesian, the only thing we need to estimate is the location of the maximum of the likelihood (point estimate!):\n\n$$\\begin{align}\n\\hat{\\mathbf{z}}_{\\text{mle}} &= \\underset{z}{\\mathrm{argmin}}\\left[\\text{NLL}(\\mathbf{z})\\right]\n\\\\\n&= \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{n=1}^{N}\\log{ p(y=y_n|\\mathbf{x}=\\mathbf{x}_n, \\mathbf{z})}\\right]\n\\end{align}\n$$\n\nIn Lecture 9 we allowed scikit-learn to find the minimum for us! But today we will actually determine this minimum...\n\nYou already did this in the Homework of Lecture 8 for the 1D case with a linear polynomial basis and fixing $x$. The multivariate case for a general basis function and for different $\\mathbf{x}$ is just as easy! Especially when considering the variance of the observation distribution to be the same everywhere!\n\n$$\n\\begin{align}\n\\hat{\\mathbf{z}}_{\\text{mle}} &= \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{n=1}^{N}\\log{ p(y=y_n|\\mathbf{x}=\\mathbf{x}_n, \\mathbf{z})}\\right] \\\\\n&= \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{n=1}^{N}\\log{\\left( \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp\\left\\{ -\\frac{1}{2\\sigma^2}\\left[y_n-\\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2\\right\\}\\right)}\\right]\\\\\n&= \\underset{z}{\\mathrm{argmin}}\\left[\\frac{N}{2}\\log{\\left(2\\pi \\sigma^2\\right)}+\\frac{1}{2 \\sigma^2}\\sum_{n=1}^{N}\\left[y_n-\\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2 \\right]\\\\\n\\end{align}\n$$\n\nwhere we recall that the unknowns are $\\mathbf{z} = (\\mathbf{w}, \\sigma)$.\n\nTo find the minimum location we need to take the gradient of the $\\text{NLL}(\\mathbf{z})$ wrt $\\mathbf{z}$ and equal it to zero:\n\n$$\n\\nabla_{\\mathbf{z}} \\text{NLL}(\\mathbf{z}) = \\mathbf{0}\n$$\n\nwhich can be written as,\n\n$$\n\\begin{bmatrix}\n\\frac{\\partial \\text{NLL}(\\mathbf{z})}{\\partial w_0}\\\\\n\\frac{\\partial \\text{NLL}(\\mathbf{z})}{\\partial w_1}\\\\\n\\vdots \\\\\n\\frac{\\partial \\text{NLL}(\\mathbf{z})}{\\partial w_M}\\\\\n\\frac{\\partial \\text{NLL}(\\mathbf{z})}{\\partial \\sigma^2}\\\\\n\\end{bmatrix} =\n\\begin{bmatrix}0\\\\\n0\\\\\n\\vdots \\\\\n0\\\\\n0\\\\\n\\end{bmatrix}\n$$\n\nWe can first solve this system of equations wrt $\\mathbf{w}$, and then solve wrt $\\sigma$\n\nThen, solving first for the weights $\\mathbf{w}$:\n\n$$\n\\nabla_{\\mathbf{w}} \\text{NLL}(\\mathbf{w}, \\sigma^2) = \\mathbf{0}\n$$\n\nwe note that,\n\n$$\\begin{align}\n\\nabla_{\\mathbf{w}} \\text{NLL}(\\mathbf{w}, \\sigma^2) = \\mathbf{0} \\\\\n\\nabla_{\\mathbf{w}} \\left[\\frac{N}{2}\\log{\\left(2\\pi \\sigma^2\\right)}+\\frac{1}{2 \\sigma^2}\\sum_{n=1}^{N}\\left[y_n-\\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2 \\right] = \\mathbf{0} \\\\\n\\nabla_{\\mathbf{w}} \\left[\\underbrace{\\frac{1}{2}\\sum_{n=1}^{N}\\left[y_n-\\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2}_{\\text{RSS}(\\mathbf{w})} \\right] = \\mathbf{0}\n\\end{align}\n$$\n\nNote: in Statistics the term in the argument is called **residual sum of squares**.\n\nWe can rewrite the above expression in a simpler form:\n\n$$\\begin{align}\n\\nabla_{\\mathbf{w}} \\left[\\frac{1}{2}\\sum_{n=1}^{N}\\left[y_n-\\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2 \\right] = 0 \\\\\n\\nabla_{\\mathbf{w}} \\left[\\frac{1}{2}\\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right)^T \\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right) \\right] = 0\n\\end{align}\n$$\n\nwhere we group all output measurements $y_n$ into a $N\\times 1$ vector $\\mathbf{y}$ and where we group all $N$ evaluations of the basis functions into the $N\\times M$ matrix:\n\n$$\n\\boldsymbol{\\Phi} = \\begin{bmatrix} \\phi_0(\\mathbf{x}_1) & \\phi_1(\\mathbf{x}_1) & \\cdots & \\phi_{M-1}(\\mathbf{x}_1) \\\\\n\\phi_0(\\mathbf{x}_2) & \\phi_1(\\mathbf{x}_2) & \\cdots & \\phi_{M-1}(\\mathbf{x}_2) \\\\\n\\vdots & \\vdots & \\ddots & \\vdots \\\\\n\\phi_0(\\mathbf{x}_N) & \\phi_1(\\mathbf{x}_N) & \\cdots & \\phi_{M-1}(\\mathbf{x}_N) \\\\\n\\end{bmatrix}\n$$\n\nSetting the gradient wrt all $\\mathbf{w}$ to zero gives,\n\n$$\\begin{align}\n\\nabla_{\\mathbf{w}} \\left[\\frac{1}{2}\\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right)^T \\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right) \\right] = \\mathbf{0}\\\\\n\\frac{1}{2} \\left[ \\left( \\boldsymbol{\\Phi}^T\\boldsymbol{\\Phi}+\\boldsymbol{\\Phi}^T\\boldsymbol{\\Phi} \\right)\\mathbf{w} -\\boldsymbol{\\Phi}^T\\mathbf{y}-\\boldsymbol{\\Phi}^T\\mathbf{y} \\right] = \\mathbf{0}\n\\end{align}\n$$\n\nwhere we used the identity $ \\frac{\\partial \\mathbf{x}^T\\mathbf{A}\\mathbf{x}}{\\partial \\mathbf{x}} = \\left( \\mathbf{A}+\\mathbf{A}^T\\right)\\mathbf{x}$. (See Section 7.8 of Murphy's book if you need to revise matrix calculus).\n\nFrom which we reach the MLE prediction for the weights:\n\n$$\n\\hat{\\mathbf{w}}_{\\text{mle}} = \\left(\\boldsymbol{\\Phi}^T \\boldsymbol{\\Phi} \\right)^{-1} \\boldsymbol{\\Phi}^T \\mathbf{y}\n$$\n\nWe conclude that our point estimate for the posterior (MLE) is: $\\hat{\\mathbf{w}}_{\\text{MLE}} = \\left(\\boldsymbol{\\Phi}^T \\boldsymbol{\\Phi} \\right)^{-1} \\boldsymbol{\\Phi}^T \\mathbf{y}$\n\nwhere the quantity\n\n$$\\boldsymbol{\\Phi}^{\\dagger} = \\left(\\boldsymbol{\\Phi}^T \\boldsymbol{\\Phi} \\right)^{-1} \\boldsymbol{\\Phi}^T $$\n\nis known as the Moore-Penrose pseudo-inverse of the matrix $\\boldsymbol{\\Phi}$. It can be regarded as a generalization of the notion of matrix inverse to **nonsquare matrices**. In the special case of $\\boldsymbol{\\Phi}$ being square and invertible, then using the property $\\left( \\mathbf{A}\\mathbf{B}\\right)^{-1}=\\mathbf{B}^{-1}\\mathbf{A}^{-1}$ we see that $\\boldsymbol{\\Phi}^{\\dagger}=\\boldsymbol{\\Phi}^{-1}$.\n\nAlso note that we could have calculated separetely the bias term $w_0$ (which is convenient because for other models the bias usually has a uniform prior, unlike the remaining weights). If we do that we obtain:\n\n$$\n\\hat{w}_0 = \\bar{y}-\\sum_{m=1}^{M-1} w_m \\bar{\\phi}_m\n$$\n\nwhere we defined $\\bar{y} = \\frac{1}{N}\\sum_{n=1}^N y_n$ and $\\bar{\\phi}_m = \\frac{1}{N}\\sum_{n=1}^{N} \\phi_m(\\mathbf{x}_n)$.\n\nHaving found the solution for all $\\mathbf{w}$, we just need to find one last unknown from the point estimate of the posterior:\n\n$$\n\\nabla_{\\mathbf{\\sigma^2}} \\text{NLL}(\\mathbf{w}, \\sigma^2) = 0\n$$\n\nwhich is particularly simple:\n\n$$\n\\hat{\\sigma}_{\\text{mle}} = \\frac{1}{N}\\sum_{n=1}^{N} \\left[y_n -\\hat{\\mathbf{w}}^T_{\\text{mle}}\\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2\n$$\n\nIn summary, the MLE point estimate of the posterior leads to the following estimation of parameters:\n\n$$\n\\hat{\\mathbf{w}}_{\\text{mle}} = \\left(\\boldsymbol{\\Phi}^T \\boldsymbol{\\Phi} \\right)^{-1} \\boldsymbol{\\Phi}^T \\mathbf{y}\n$$\n\n$$\n\\hat{\\sigma}_{\\text{mle}} = \\frac{1}{N}\\sum_{n=1}^{N} \\left[y_n -\\hat{\\mathbf{w}}^T_{\\text{mle}}\\boldsymbol{\\phi}(\\mathbf{x}_n)\\right]^2\n$$\n\nwhere the Moore-Penrose pseudo inverse needs to be calculated $\\boldsymbol{\\Phi}^{\\dagger} = \\left(\\boldsymbol{\\Phi}^T \\boldsymbol{\\Phi} \\right)^{-1} \\boldsymbol{\\Phi}^T $.\n\nThis calculation can be done efficiently by many libraries, including Numpy.\n\n* For example, scikit-learn uses a solver based on SVD (Single Value Decomposition: the most common dimensionality reduction method) which is efficient when $N > M$ (overdetermined system). Book section 7.5 has an excellent summary of SVD, if you are curious.\n\n* Of course, if $N = M$ then there is a unique solution (you know that from the Midterm!) and the error on the training set becomes zero (linear regression becomes fully interpolatory).\n\n## Ridge regression: Linear regression with Gaussian likelihood, Gaussian prior and posterior via Point estimate\n\n| Likelihood | Prior (on the weights) | Posterior | Name of the model | Book section |\n|--- |--- |--- |--- |--- |\n| Gaussian | Gaussian | Point estimate | Ridge regression | 11.3 |\n\n1. Gaussian observation distribution: $p(y|\\mathbf{x}, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}), \\sigma_{y|z}^2 = \\sigma^2)$\n\nwhere $\\mathbf{z} = (\\mathbf{w}, \\sigma)$ are all the unknown model parameters (hidden rv's).\n\n2. But using a Gaussian prior for the weights $\\mathbf{w}$: $p(\\mathbf{w}) = \\mathcal{N}(\\mathbf{w}| \\mathbf{0}, \\overset{\\scriptscriptstyle <}{\\sigma}_w \\mathbf{I})$\n\n3. MAP point estimate for posterior: $\\hat{\\mathbf{z}}_{\\text{map}} = \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{i=1}^{N}\\log{ p(y=y_i|z)} - \\log{p(\\mathbf{w})}\\right]$\n\nFinal prediction is given by the PPD : $\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\int p(y|z) \\delta(z-\\hat{z}_{\\text{map}}) dz = p(y|z=\\hat{z}_{\\text{map}})$\n\n#### Note on the choice of prior for linear regression\n\nThe Gaussian prior is usually imposed only on the weights. The bias and variance term in the observation distribution still have a Uniform prior because they do not contribute to overfitting.\n\nYou can see this from the expressions for $\\hat{w}_{0, \\text{mle}}$ and $\\sigma^2_{\\text{mle}}$, as they act on the global mean and MSE (mean squared error) of the residuals, respectively.\n\nComputing the MAP estimate is very similar to what we did for the MLE:\n\n$$\n\\begin{align}\n\\hat{\\mathbf{w}}_{\\text{map}} &= \\underset{w}{\\mathrm{argmin}}\\left[\\frac{1}{2\\sigma^2}\\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right)^T \\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right) + \\frac{1}{2\\overset{\\scriptscriptstyle <}{\\sigma}_w^2}\\mathbf{w}^T\\mathbf{w}\\right] \\\\\n&= \\underset{w}{\\mathrm{argmin}}\\left[\\text{RSS}(\\mathbf{w}) + \\lambda ||\\mathbf{w}||_2^2\\right]\n\\end{align}\n$$\n\nwhere $\\lambda = \\frac{\\sigma^2}{\\overset{\\scriptscriptstyle <}{\\sigma}_w^2}$ is proportional to the strength of the prior, and\n\n$||\\mathbf{w}||_2^2 = \\sqrt{\\sum_{m=1}^{M-1} |w_m|^2} = \\sqrt{\\mathbf{w}^T\\mathbf{w}}$\n\nis called the $l_2$ norm of the vector $\\mathbf{w}$. Thus, we are penalizing weights that become too large in magnitude. In ML literature this is usually called $l_2$ **regularization** or **weight decay**, and is very widely used.\n\n\nIn the midterm, you will experience the difference between Linear Least Squares and Ridge regression, reporting on the influence of the prior strength for the latter.\n\nThen, solving the MAP first for the weights $\\mathbf{w}$, as we did for the MLE:\n\n$$\\begin{align}\n\\nabla_{\\mathbf{w}} \\left[\\frac{1}{2\\sigma^2}\\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right)^T \\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right) + \\frac{1}{2\\overset{\\scriptscriptstyle <}{\\sigma}_w^2}\\mathbf{w}^T\\mathbf{w}\\right] &= \\mathbf{0} \\\\\n\\nabla_{\\mathbf{w}} \\left[\\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right)^T \\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right) + \\lambda\\mathbf{w}^T\\mathbf{w}\\right] = \\mathbf{0}\n\\end{align}\n$$\n\nfrom which we determine the MAP estimate for the the weights $\\mathbf{w}$ as:\n\n$$\n\\hat{\\mathbf{w}}_{\\text{map}} = \\left( \\boldsymbol{\\Phi}^T\\boldsymbol{\\Phi} + \\lambda \\mathbf{I}_M \\right)^{-1} \\boldsymbol{\\Phi}^T \\mathbf{y} = \\left( \\sum_{n=1}^{N} \\boldsymbol{\\phi}(\\mathbf{x}_n)\\boldsymbol{\\phi}(\\mathbf{x}_n)^T + \\lambda \\mathbf{I}_M \\right)^{-1} \\left( \\sum_{n=1}^{N} \\boldsymbol{\\phi}(\\mathbf{x}_n) y_n \\right)\n$$\n\nOnce again, this can be solved using SVD or other methods to ensure that the Moore-Penrose pseudoi inverse is calculated properly.\n\n## Lasso regression: Linear regression with Gaussian likelihood, Laplace prior and posterior via Point estimate\n\n| Likelihood | Prior (on the weights) | Posterior | Name of the model | Book section |\n|--- |--- |--- |--- |--- |\n| Gaussian | Laplace | Point estimate | Lasso regression | 11.4 |\n\n1. Gaussian observation distribution: $p(y|\\mathbf{x}, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(\\mathbf{x}), \\sigma_{y|z}^2 = \\sigma^2)$\n\nwhere $\\mathbf{z} = (\\mathbf{w}, \\sigma)$ are all the unknown model parameters (hidden rv's).\n\n2. But using a **Laplace** prior for the weights $\\mathbf{w}$: $p(\\mathbf{w}) = \\prod_{m=1}^{M-1}\\text{Lap}\\left(w_m| 0, 1/\\overset{\\scriptscriptstyle <}{\\lambda}_w\\right) \\propto \\prod_{m=1}^{M-1} \\exp{\\left[ -\\overset{\\scriptscriptstyle <}{\\lambda}_w |w_m|\\right]}$\n\n3. MAP point estimate for posterior: $\\hat{\\mathbf{z}}_{\\text{map}} = \\underset{z}{\\mathrm{argmin}}\\left[-\\sum_{i=1}^{N}\\log{ p(y=y_i|z)} - \\log{p(\\mathbf{w})}\\right]$\n\nFinal prediction is given by the PPD : $\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\int p(y|z) \\delta(z-\\hat{z}_{\\text{map}}) dz = p(y|z=\\hat{z}_{\\text{map}})$\n\n#### Note about the sparsity parameter $\\overset{\\scriptscriptstyle <}{\\lambda}_w$\n\nPlease note that the $\\overset{\\scriptscriptstyle <}{\\lambda}_w$ parameter defining the strength of the Laplace prior is different from the $\\lambda$ parameter defined in Ridge regression.\n\n#### Note about number of parameters $M$ and number of input dimensions $D$\n\nIf $M=D$ the method is called Lasso, but if there are more parameters than input variables $M>D$ then it is called Group Lasso (Section 11.4.7).\n\n* The next cells describe Lasso, which introduces sparsity by making a weight associated to a particular variable tending to zero.\n\n* Group Lasso leads to a sparsity of more than one parameter that is associated to a given variable (which is an interesting way to induce sparsity in overparameterized models such as Artificial Neural Networks). It is derived in a very similar manner.\n\nComputing the MAP estimate:\n\n$$\n\\begin{align}\n\\hat{\\mathbf{w}}_{\\text{map}} &= \\underset{w}{\\mathrm{argmin}}\\left[\\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right)^T \\left(\\boldsymbol{\\Phi}\\mathbf{w} - \\mathbf{y}\\right) + \\overset{\\scriptscriptstyle <}{\\lambda}_w||\\mathbf{w}||_1\\right]\n\\end{align}\n$$\n\nwhere $||\\mathbf{w}||_1 = \\sum_{m=1}^{M-1}|w_m|$ is called the $l_1$ norm of $\\mathbf{w}$. In ML literature this is called $l_1$ regularization. \n\n* Calculating the MAP for Lasso is not done the same way as for Ridge because the term $||\\mathbf{w}||_1$ is not differentiable whenever $w_m = 0$. In this case, the solution is found using hard- or soft-thresholding (See Section 11.4.3 in the book) because the gradient becomes a branch function.\n\n* A more important point is to see that **different types of prior distributions** introduce **different regularizations** on the weights, aleviating overfitting in a different manner.\n - For example, in the case of Lasso, since the Laplace prior puts more density around the mean (which is zero here) than the Gaussian prior, then it has a tendency to lead the weights to zero, i.e. it introduces **sparsity** when estimating the weights via MAP. The book has a beautiful discussion about this.\n\n## Bayesian linear regression: Linear regression with Gaussian likelihood, Gaussian prior and Gaussian posterior (Bayesian solution)\n\nAs we saw in the beginning of the Lecture, there are many more models we can define! The book covers quite a few!\n\n| Likelihood | Prior (on the weights) | Posterior | Name of the model | Book section |\n|--- |--- |--- |--- |--- |\n| Gaussian | Gaussian | Gaussian | Bayesian linear regression | 11.7 |\n\n1. Gaussian observation distribution (with known variance): $p(y|x, \\mathbf{z}) = \\mathcal{N}(y| \\mu_{y|z} = \\mathbf{w}^T \\boldsymbol{\\phi}(x), \\sigma_{y|z}^2 = \\sigma^2)$\n\nwhere $\\mathbf{z} = (\\mathbf{w}, \\sigma)$ are all the unknown model parameters (hidden rv's).\n\n2. Gaussian prior for the weights $\\mathbf{w}$: $p(\\mathbf{w}) = \\mathcal{N}(\\mathbf{w}| \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\mu}}_w, \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\Sigma}}_w)$\n\n3. Gaussian posterior (obtained from Bayes rule)\n\nFinal prediction is given by the PPD : $\\require{color}\n{\\color{orange}p(y|x, \\mathcal{D})} = \\int p(y|x,\\mathbf{z}) p(\\mathbf{z}|\\mathcal{D}) dz$\n\nAt this point you may notice that we have already derived this model in Lecture 7.\n\nThe only differences are that now we have multiple weights $\\mathbf{z}$, multidimensional inputs $\\mathbf{x}$ and that we allow them to have different values.\n\nYet, the derivation is the same! We just need to bold the letters. Let's do it:\n\nThe likelihood is a (multivariate) Gaussian distribution (product of MVN evaluated at each data point):\n\n$$\np(\\mathcal{D}|\\mathbf{w}, \\sigma^2) = \\prod_{n=1}^N p(y_n | \\mathbf{w}^T\\boldsymbol{\\phi}(\\mathbf{x}), \\sigma^2) = \\mathcal{N}(\\mathbf{y} | \\boldsymbol{\\Phi}\\mathbf{w}, \\sigma^2 \\mathbf{I}_N)\n$$\n\nwhere $\\mathbf{I}_N$ is the $N\\times N$ identity matrix, as defined previously.\n\nTo calculate the posterior, we also use the product of Gaussians rule (Lecture 5 in the cell after the Homework we also defined this rule for multivariate Gaussians!):\n\n$$\np(\\mathbf{w}| \\boldsymbol{\\Phi}, \\mathbf{y}, \\sigma^2) \\propto \\mathcal{N}(\\mathbf{y} | \\boldsymbol{\\Phi}\\mathbf{w}, \\sigma^2 \\mathbf{I}_N) \\mathcal{N}(\\mathbf{w}| \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\mu}}_w, \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\Sigma}}_w) = \\mathcal{N}(\\mathbf{w}| \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}_w, \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w)\n$$\n\nwhere the mean and covariance of the posterior are given by:\n\n$$\n\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}_w = \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w \\left( \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\Sigma}}_w \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\mu}}_w + \\frac{1}{\\sigma^2}\\boldsymbol{\\Phi}^T\\mathbf{y}\\right)\n$$\n\n$$\n\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w = \\left( \\overset{\\scriptscriptstyle <}{\\boldsymbol{\\Sigma}}_w + \\frac{1}{\\sigma^2}\\boldsymbol{\\Phi}^T\\boldsymbol{\\Phi}\\right)^{-1}\n$$\n\nOften, we use a prior with zero mean $\\overset{\\scriptscriptstyle <}{\\boldsymbol{\\mu}}_w =\\mathbf{0}$ and diagonal covariance $\\overset{\\scriptscriptstyle <}{\\boldsymbol{\\Sigma}}_w = \\overset{\\scriptscriptstyle <}{\\sigma}_w^2 \\mathbf{I}_M$ like the prior we used in Ridge regression. In this case, the posterior mean becomes the same as the MAP estimate obtained from Ridge regression: $\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}_w =\\left( \\lambda \\mathbf{I}_M + \\boldsymbol{\\Phi}^T\\boldsymbol{\\Phi}\\right)^{-1} \\boldsymbol{\\Phi}^T \\mathbf{y}$.\n\n#### Note on the reduction of the posterior mean for Bayesian linear regression to the MAP estimate of Ridge regression \n\nIf we use a prior with zero mean $\\overset{\\scriptscriptstyle <}{\\boldsymbol{\\mu}}_w =\\mathbf{0}$ and diagonal covariance $\\overset{\\scriptscriptstyle <}{\\boldsymbol{\\Sigma}}_w = \\overset{\\scriptscriptstyle <}{\\sigma}_w^2 \\mathbf{I}_M$ then the posterior mean becomes\n\n$$\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}_w = \\frac{1}{\\overset{\\scriptscriptstyle <}{\\sigma}_w^2} \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w \\boldsymbol{\\Phi}^T\\mathbf{y}\n$$\n\nwhich is the same as the Ridge regression estimate when we define $\\lambda = \\frac{\\sigma^2}{\\overset{\\scriptscriptstyle <}{\\sigma}_w^2}$,\n\n$\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}_w =\\left( \\lambda \\mathbf{I}_M + \\boldsymbol{\\Phi}^T\\boldsymbol{\\Phi}\\right)^{-1} \\boldsymbol{\\Phi}^T \\mathbf{y}$\n\nHaving determined the posterior, we can determine what we really want: the PPD.\n\n$$\n\\begin{align}\n{\\color{orange}p(y|x, \\mathcal{D})} &= \\int p(y|x,\\mathbf{z}) p(\\mathbf{z}|\\mathcal{D}) d\\mathbf{z} \\\\\np(y|x, \\mathcal{D}, \\sigma^2) &= \\int p(y|x,\\mathbf{w}, \\sigma^2) p(\\mathbf{w}|\\mathcal{D}) d\\mathbf{w} \\\\\n&= \\int \\mathcal{N}(y | \\boldsymbol{\\phi}(\\mathbf{x})^T\\mathbf{w}, \\sigma^2) \\mathcal{N}(\\mathbf{w}| \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}_w, \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w) dw \\\\\n&= \\mathcal{N}\\left(y \\mid \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}^T_w \\boldsymbol{\\phi}(\\mathbf{x}) \\,,\\, \\sigma^2 + \\boldsymbol{\\phi}(\\mathbf{x})^T \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w \\boldsymbol{\\phi}(\\mathbf{x})\\right)\n\\end{align}\n$$\n\nwhere we recall the meaning of each term:\n\n* ($\\mathbf{x}$, $y$) is the point were we want to make a prediction\n* $\\boldsymbol{\\phi}(\\mathbf{x})$ is an $M\\times 1$ vector of basis functions\n* $\\overset{\\scriptscriptstyle <}{\\boldsymbol{\\mu}}_w$ is the $M\\times 1$ vector with the mean of the posterior for the weights\n* and $\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w$ is the $M \\times M$ covariance matrix of the posterior for the weights.\n\n#### Note about integration of the PPD\n\nThe book uses the following notation:\n\n$$\\begin{align}\np(y|x, \\mathcal{D}, \\sigma^2) &= \\int p(y|x,\\mathbf{w}, \\sigma^2) p(\\mathbf{w}|\\mathcal{D}) d\\mathbf{w}\n\\end{align}\n$$\n\nWe could be more explicit and use the following notation:\n\n$$\\begin{align}\np(y|x, \\mathcal{D}, \\sigma^2) &= \\int p(y|x,\\mathbf{w}, \\sigma^2) p(\\mathbf{w}|\\mathcal{D}) d^{M-1}\\mathbf{w} \\\\\n&= \\int\\int\\cdots \\int p(y|x,\\mathbf{w}, \\sigma^2) p(\\mathbf{w}|\\mathcal{D}) dw_1 dw_2 \\cdots dw_{M-1}\n\\end{align}\n$$\n\nwhere it is clear that we are integrating for all variables (not integrating to get a vector).\n\nHowever, despite this notation being more precise, it is also less appealing. Just make sure you realize the type of integral that we are calculating when we are finding the PPD.\n\nObserving the obtained PPD,\n\n$$\n\\begin{align}\np(y|x, \\mathcal{D}, \\sigma^2) &= \\mathcal{N}\\left(y \\mid \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\mu}}^T_w \\boldsymbol{\\phi}(\\mathbf{x}) \\,,\\, \\sigma^2 + \\boldsymbol{\\phi}(\\mathbf{x})^T \\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w \\boldsymbol{\\phi}(\\mathbf{x})\\right)\n\\end{align}\n$$\n\nwe see something very interesting: the variance of the PPD at a point $\\mathbf{x}$ after seeing $N$ data points depends on two terms:\n\n1. the variance of the observation noise, $\\sigma^2$ that we defined to be constant\n\n2. and the variance in the parameters obtained by the posterior $\\overset{\\scriptscriptstyle >}{\\boldsymbol{\\Sigma}}_w$\n\nThis means that the predicted uncertainty increases when $\\mathbf{x}$ is located far from the training data $\\mathcal{D}$, just like we want it to be! We are less certain about points **away** from our observations (training data).\n\nWe have seen this happening in Gaussian processes too... You will see that Gaussian processes are not too different from Bayesian linear regression...\n\n## Other linear regression models\n\nAs we saw in the beginning of the Lecture, there are many more models we can define! The book covers quite a few!\n\n| Likelihood | Prior (on the weights) | Posterior | Name of the model | Book section |\n|--- |--- |--- |--- |--- |\n| Gaussian | Uniform | Point estimate | Least Squares regression | 11.2.2 |\n| Gaussian | Gaussian | Point estimate | Ridge regression | 11.3 |\n| Gaussian | Laplace | Point estimate | Lasso regression | 11.4 |\n| Gaussian | Gaussian$\\times$Laplace | Point estimate | Elastic net | 11.4.8 |\n| Student-$t$ | Uniform | Point estimate | Robust regression | 11.6.1 |\n| Laplace | Uniform | Point estimate | Robust regression | 11.6.2 |\n| Gaussian | Gaussian | Gaussian | Bayesian linear regression | 11.7 |\n\nFor example, the \"Elastic net\" is literally the combination of Ridge regression and Lasso by defining a prior that depends on both a Gaussian and a Laplace distribution. This model was proposed in 2005. Five years later the \"Bayesian Elastic Net\" was also proposed, where the posterior is calculated in a Bayesian way (just like what we did for Bayesian linear regression).\n\n## In summary\n\nAlmost every ML model is derived following 4 steps:\n\n1. Define the Observation distribution and compute the likelihood.\n\n2. Define the prior and its parameters.\n\n3. Compute the posterior to estimate the unknown parameters (whether via a Bayesian approach or via a Point estimate).\n\n4. Compute the PPD.\n\nDone.\n\nIf you only care about the mean of the PPD (the mean of your prediction), then you can compute it directly without even thinking about uncertainty... But then, make sure you characterize the quality of your predictions using an appropriate **error metric** and use strategies like cross-validation, like you did for your Midterm Project!\n\n### See you next class\n\nHave fun!\n", "meta": {"hexsha": "68276fbcc256800b6ab2a62ec23c477a4df19705", "size": 48639, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture13/3dasm_Lecture13.ipynb", "max_stars_repo_name": "shushu-qin/3dasm_course", "max_stars_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-02-07T18:45:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T21:45:27.000Z", "max_issues_repo_path": "Lectures/Lecture13/3dasm_Lecture13.ipynb", "max_issues_repo_name": "shushu-qin/3dasm_course", "max_issues_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture13/3dasm_Lecture13.ipynb", "max_forks_repo_name": "shushu-qin/3dasm_course", "max_forks_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2022-02-07T18:45:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T19:30:17.000Z", "avg_line_length": 46.1033175355, "max_line_length": 585, "alphanum_fraction": 0.578753675, "converted": true, "num_tokens": 11209, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.26284183737131667, "lm_q2_score": 0.3998116407397951, "lm_q1q2_score": 0.1050872262544885}}
{"text": "\n\n# Explainable Recommendations\n\n\nWhile the main objective of a recommender system is to identify the items to be recommended to a user, providing explanations to accompany the recommendations would be more persuasive as well as engender trust and transparency. There are different types of explanations. In this tutorial, we explore explainable recommendation approaches that rely on user product aspect-level sentiment for modeling explanations.\n\n## 1. Setup\n\n\n```\n!pip install --quiet cornac==1.6.1\n```\n\n \u001b[K |████████████████████████████████| 10.1MB 3.1MB/s \n \u001b[?25h\n\n\n```\nimport os\nimport sys\nfrom collections import defaultdict\n\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nimport cornac\nfrom cornac.utils import cache\nfrom cornac.datasets import amazon_toy\nfrom cornac.eval_methods import RatioSplit\nfrom cornac.data import Reader, SentimentModality\nfrom cornac.models import EFM, MTER, NMF, BPR\n\nprint(f\"System version: {sys.version}\")\nprint(f\"Cornac version: {cornac.__version__}\")\n\nSEED = 42\nVERBOSE = False\n```\n\n System version: 3.6.9 (default, Apr 18 2020, 01:56:04) \n [GCC 8.4.0]\n Cornac version: 1.6.1\n\n\n## 2. Aspect-Level Sentiments\nTo model fine-grained product aspect-ratings. Several works rely on sentiment analysis to extract aspect sentiment from product reviews. In other words, each review is now a list of aspect sentiments. Along with product rating, we also have aspect sentiments expressed in users' reviews. Here, we work with Toys and Games dataset, a sub-category of [Amazon reviews](http://jmcauley.ucsd.edu/data/amazon/).\n\nBelow are some examples of aspect-level sentiments that have been extracted from users' reviews of items.\n\n\n```\nsentiment = amazon_toy.load_sentiment()\nsamples = sentiment[:10]\npd.DataFrame.from_dict({\n \"user\": [tup[0] for tup in samples],\n \"item\": [tup[1] for tup in samples],\n \"aspect-level sentiment\": [tup[2] for tup in samples]\n})\n```\n\n\n\n\n\n\n
\n \n \n user \n item \n aspect-level sentiment \n \n \n \n \n 0 \n A012468118FTQAINEI0OQ \n B00005BZM6 \n [(paint, great, 1)] \n \n \n 1 \n A012468118FTQAINEI0OQ \n B001HA9JOA \n [(game, great, 1), (money, worth, 1)] \n \n \n 2 \n A012468118FTQAINEI0OQ \n B002BY2BVE \n [(paint, fun, 1), (item, well, 0)] \n \n \n 3 \n A012468118FTQAINEI0OQ \n B007U7M0LI \n [(price, sturdy, 1)] \n \n \n 4 \n A012468118FTQAINEI0OQ \n B00804BCO6 \n [(gift, great, 1)] \n \n \n 5 \n A0182108CPDLPRCXQUZQ \n B002IUNLLK \n [(toy, best, 1), (heavy, cool, 1)] \n \n \n 6 \n A0182108CPDLPRCXQUZQ \n B007WYU7R8 \n [(toy, great, 1)] \n \n \n 7 \n A0182108CPDLPRCXQUZQ \n B00ABY8WVO \n [(toy, love, 1)] \n \n \n 8 \n A0182108CPDLPRCXQUZQ \n B00AFP86KG \n [(toy, love, 1)] \n \n \n 9 \n A0182108CPDLPRCXQUZQ \n B00BJT861Q \n [(figure, well, 1), (toy, well, 1)] \n \n \n
\n
\n\n
\n \n \n paint \n game \n money \n item \n price \n \n \n \n \n User 1 \n 0.0 \n 0.000000 \n 0.0 \n 0.000000 \n 2.848469 \n \n \n User 2 \n 0.0 \n 0.000000 \n 0.0 \n 0.000000 \n 0.000000 \n \n \n User 3 \n 0.0 \n 4.620593 \n 0.0 \n 2.848469 \n 4.620593 \n \n \n User 4 \n 0.0 \n 4.856110 \n 0.0 \n 0.000000 \n 0.000000 \n \n \n User 5 \n 0.0 \n 0.000000 \n 0.0 \n 0.000000 \n 0.000000 \n \n \n
\n
\n\n
\n \n \n paint \n game \n money \n item \n price \n \n \n \n \n Item 1 \n 3.924234 \n 0.000000 \n 3.000000 \n 0.000000 \n 3.924234 \n \n \n Item 2 \n 0.000000 \n 0.000000 \n 0.000000 \n 4.523188 \n 4.523188 \n \n \n Item 3 \n 0.000000 \n 4.523188 \n 0.000000 \n 0.000000 \n 0.000000 \n \n \n Item 4 \n 0.000000 \n 0.000000 \n 0.000000 \n 0.000000 \n 3.924234 \n \n \n Item 5 \n 3.924234 \n 0.000000 \n 3.924234 \n 4.523188 \n 4.523188 \n \n \n
\n
\n\n
\n \n \n aspect \n user_aspect_attention_score \n item_aspect_quality_score \n \n \n \n \n 0 \n toy \n 4.061583 \n 4.679122 \n \n \n 1 \n pieces \n 3.610668 \n 3.844794 \n \n \n 2 \n game \n 3.571418 \n 4.211304 \n \n \n 3 \n furby \n 3.571004 \n 4.787230 \n \n \n 4 \n doll \n 3.480351 \n 4.326976 \n \n \n 5 \n quality \n 3.468948 \n 3.952711 \n \n \n 6 \n really \n 3.368340 \n 4.586975 \n \n \n 7 \n gift \n 3.364289 \n 4.410737 \n \n \n 8 \n also \n 3.360865 \n 4.076249 \n \n \n 9 \n puzzle \n 3.294265 \n 4.726530 \n \n \n
\n
\n\n
\n \n \n aspect \n top_opinions \n explanation \n \n \n \n \n 0 \n really \n [disappointed, great, like] \n Its really is [disappointed] [great] [like]. \n \n \n 1 \n addition \n [disappointed, great, fun] \n Its addition is [disappointed] [great] [fun]. \n \n \n
\n
's in the pivot positions, with $0$'s below and above each).\n\n$$ \\begin{bmatrix} 1 & 3 & 1 & 0 \\\\ 2 & 7 & 0 & 1 \\end{bmatrix}\\rightarrow \\begin{bmatrix} 1 & 3 & 1 & 0 \\\\ 0 & 1 & -2 & 1 \\end{bmatrix}\\rightarrow \\begin{bmatrix} 1 & 0 & 7 & -3 \\\\ 0 & 1 & -2 & 1 \\end{bmatrix} \\tag{9}$$\n\nWe now read off the two columns of $A^{-1}$.\n\n $$ \\begin{bmatrix}7&-3\\\\-2&1\\end{bmatrix} \\tag{10}$$\n\n## Example problems\n\n\n### Example problem 1\n\nFind the conditions on $a$ and $b$ that makes the matrix $A$ invertible and find $A^{-1}$.|\n\n$$ A=\\begin{bmatrix} a & b & b \\\\ a & a & b \\\\ a & a & a \\end{bmatrix} \\tag{11} $$\n\n#### Solution\n\n1. A matrix is singular (non-invertible) if we have a row or column of zeros, so $a \\ne 0$\n2. We can also not have similar columns, so $a \\ne b$\n\nUsing Gauss-Jordan elimination we will have the following.\n\n\n\n$$ \\begin{bmatrix} a & b & b & 1 & 0 & 0 \\\\ a & a & b & 0 & 1 & 0 \\\\ a & a & a & 0 & 0 & 1 \\end{bmatrix}\\rightarrow \\begin{bmatrix} a & b & b & 1 & 0 & 0 \\\\ 0 & a-b & 0 & -1 & 1 & 0 \\\\ 0 & a-b & a-b & -1 & 0 & 1 \\end{bmatrix}\\rightarrow \\begin{bmatrix} a & b & b & 1 & 0 & 0 \\\\ 0 & a-b & 0 & -1 & 1 & 0 \\\\ 0 & 0 & a-b & 0 & -1 & 1 \\end{bmatrix}\\\\ \\rightarrow \\begin{bmatrix} a & b & b & 1 & 0 & 0 \\\\ 0 & \\frac { a-b }{ a-b } & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } & 0 \\\\ 0 & 0 & \\frac { a-b }{ a-b } & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } \\end{bmatrix}\\rightarrow \\begin{bmatrix} a & b & b & 1 & 0 & 0 \\\\ 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } & 0 \\\\ 0 & 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } \\end{bmatrix}\\\\ \\rightarrow \\begin{bmatrix} a & b & 0 & 1 & \\frac { 1 }{ a-b } \\left( b \\right) & -\\frac { 1 }{ a-b } \\left( b \\right) \\\\ 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } & 0 \\\\ 0 & 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } \\end{bmatrix}\\rightarrow \\begin{bmatrix} a & 0 & 0 & 1+\\frac { b }{ a-b } & 0 & -\\frac { 1 }{ a-b } \\left( b \\right) \\\\ 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } & 0 \\\\ 0 & 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } \\end{bmatrix}\\\\ \\rightarrow \\begin{bmatrix} 1 & 0 & 0 & \\frac { 1 }{ a-b } & 0 & -\\frac { 1 }{ a\\left( a-b \\right) } \\left( b \\right) \\\\ 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } & 0 \\\\ 0 & 0 & 1 & 0 & \\frac { -1 }{ a-b } & \\frac { 1 }{ a-b } \\end{bmatrix}\\\\ { A }^{ -1 }=\\frac { 1 }{ a-b } \\begin{bmatrix} 1 & 0 & \\frac { -b }{ a } \\\\ -1 & 1 & 0 \\\\ 0 & -1 & 1 \\end{bmatrix} \\tag{12}$$\n\nIf we were to construct this matrix using `sympy` and invert it using the `.inv()` method, we can deduce our findings through simple algebra, i.e. $a \\ne b$, $a \\ne 0$.\n\n\n```python\na, b = symbols('a b')\n```\n\n\n```python\nA = Matrix([[a, b, b], [a, a, b], [a, a, a]])\nA\n```\n\n\n```python\nA.inv()\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e4137d8fccd23d25cb37771077e7e80041e2e0bc", "size": 31158, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/Linear Algebra/0.0 MIT-18.06 - Jupyter/Lecture_3_Matrix_multiplication_Inverses.ipynb", "max_stars_repo_name": "okara83/Becoming-a-Data-Scientist", "max_stars_repo_head_hexsha": "f09a15f7f239b96b77a2f080c403b2f3e95c9650", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Mathematics/Linear Algebra/0.0 MIT-18.06 - Jupyter/Lecture_3_Matrix_multiplication_Inverses.ipynb", "max_issues_repo_name": "okara83/Becoming-a-Data-Scientist", "max_issues_repo_head_hexsha": "f09a15f7f239b96b77a2f080c403b2f3e95c9650", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Mathematics/Linear Algebra/0.0 MIT-18.06 - Jupyter/Lecture_3_Matrix_multiplication_Inverses.ipynb", "max_forks_repo_name": "okara83/Becoming-a-Data-Scientist", "max_forks_repo_head_hexsha": "f09a15f7f239b96b77a2f080c403b2f3e95c9650", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2022-02-09T15:41:33.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-11T07:47:40.000Z", "avg_line_length": 51.5008264463, "max_line_length": 4056, "alphanum_fraction": 0.6567815649, "converted": true, "num_tokens": 3996, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42250463481418826, "lm_q2_score": 0.24798743735585302, "lm_q1q2_score": 0.10477584165854106}}
{"text": "```python\nfrom IPython.display import HTML\n\nHTML('''\n''')\n```\n\n\n\n\n\n\n\n\n\n# 8. Shor's algorithm\n\n\nShor's factoring algorithm [1] is the most well-known example of a quantum algorithm outperforming the best known classical algorithms. The algorithm allows to factor a number $N_0$ which is the product of two prime numbers $N_0 = p \\cdot q$, in polynomial time. This is possible thanks to a theorem in number theory which turns the problem of finding factors into the problem of finding the period of a periodic function. Using the quantum Fourier transform (QFT), one can then find the period of this function with high probability and complete the factorization.\n\nThe problem of factoring numbers has been studied for centuries and no efficient (polynomial time) algorithm has ever been found. The difficulty of factoring numbers is the basis on which the most widespread encryption standard, the RSA, is founded. Therefore, an algorithm which is capable of factoring numbers efficiently could have a huge impact on the security of electronic based interactions. The discovery of this algorithm by Peter Shor in 1994, led to an explosion of the field of quantum computation because of its important application. \n\nHowever, experimental implementation of the algorithm still remains a challenge because of the errors introduced by the large number of physical qubits and gates required to execute the algorithm. Proof of principle demonstration of Shor's factoring algorithm to factor the smallest number $N_0=15$ using five superconducting qubits have been done for setups like NMR [2], trapped ions [3], photons [4-6], photonic chips [7] and superconducting qubits [8,9]. These experiments show how complex is to implement the actual algorithm, as even for the smallest number which allows the algorithm to be run ($N_0=15$), extreme simplifications must be made to run the algorithm [10]. \n\n## 8.1 Mathematical preliminaries\n\n\n\n### 8.1.1 Modular arithmetic\nWhen division between integers $a$ (the dividend) and $b$ (the divisor) is taught for the first time, one is usually introduced to the idea of quotient $q$ and remainder $r$. The quotient is the number of times the dividend $a$ contains the divisor $b$, the remainder is any left-over that added to the product of the quotient by the divisor returns the dividend, $r + q\\times b = a$ or $r = a - q\\times b$.\n\n#### Example:\nConsider the case $a=40$ and $b=30$, let us find the quotient and the remainder of the division of $a$ by $b$. $40/30 \\rightarrow q = 1, \\, r = 13$,\n\t\t \nTherefore, the quotient is $q=1$ and the remainder is $r = 13$. \n\t\n\n\nBy looking at the division between integers in this way, one can easily understand the fundamentals of modular arithmetic. Modular arithmetic is a set of rules for handling operations between integer numbers. In modular arithmetic, integers multiple of a fixed number $N_0$ are considered equivalent. Thus, by selecting an integer $N_0$, the set of all integers is restricted to the integers in the interval $\\left[ 0 , N_0-1 \\right]$. \nTo visualize this, one can think about a twelve-hours clock. In a clock, the only integers allowed lie in the interval $\\left[ 0 , 11 \\right]$, once this interval is exceeded one goes back at the beginning of the interval. Thus, $9+5 = 2 \\, \\left( mod \\, 12 \\right)$.\nMore formally, two integers $a$ and $b$ are congruent modulo $N_0$ if their difference $a-b$ is an integer multiple of $N_0$. That is, $a-b = r \\cdot N_0$, where $r$ is an integer, then $a \\equiv b \\, \\left( mod \\, N_0 \\right)$. \nEquivalently, if $a \\equiv b \\, \\left( mod \\, N_0 \\right)$, then $\\frac{a-b}{N_0}$ has zero remainder. Or, $b \\, \\left( mod \\, N_0 \\right)$ is the remainder of the division $\\frac{b}{N_0}=a$. Thus, both numbers have the same remainder when divided by $N_0$.\n\n#### Example:\nEquivalence of two integers modulo $N_0$:\n$38 \\equiv 14 \\, \\left( mod \\, 12 \\right)$\n$38 - 14 = 24 = 2 \\cdot 12 $\n\nBoth $\\frac{38}{12}$ and $\\frac{14}{12}$ have remainder $2$.\n\n\n\n### 8.1.2 Continued Fraction Algorithm\n\nThe continued fraction algorithm is used to reduce a fraction $\\frac{m}{n}$ to another fraction $\\frac{u}{t}$. In general, the algorithm allows to rewrite any irrational number as a finite/infinite sum of an integer part plus the reciprocal of a number.\nSo, consider the fraction $\\frac{m}{n}$, its continued fraction expansion is\n\n$$ \\frac{m}{n} = a_0 + \\frac{1}{a_1 + \\frac{1}{a_2+ \\frac{1}{a_3+\\frac{1}{1+\\frac{1}{a_4+\\frac{1}{a_5+\\frac{1}{...}}}}}}} $$\n\nUsing the integers $a_i$, one can rewrite the fraction $\\frac{m}{n}$ as $\\frac{u}{t}$. To find $u_i$ and $t_i$ one can use the following formulas:\n\n$u_0 = a_0$, $u_1=1+a_0a_1$, ..., $u_n = a_n d_n + d_{n-2}$\n$t_0=1$, $t_1 = a_1$, ..., $t_n =a_n t_{n−1} +t_{n−2}$ \n\nWhich then give the possible approximations for $\\frac{m}{n}$:\n\n$\\frac{m}{n} \\approx \\frac{u_0}{t_0}$, $\\frac{m}{n} \\approx \\frac{u_1}{t_1}$, ..., $\\frac{m}{n} \\approx \\frac{u_n}{t_n}$\n\n\n## 8.2 Factoring and order finding \n \n \nThe possibility of running an efficient algorithm for factoring a product of two prime number arises from: i. the connection between factoring and order finding, ii. the ability of quantum computers to deal efficiently with periodic functions.\nIn this Section, the connection between the problem of factoring and the problem of finding the period of a periodic function, also called $\\textit{order finding}$ is explained.\nIt is important to note that this equivalency holds in the realm of modular arithmetic.\nLet us start from the concept of order of a number. Given an integer $a$, the order of $a$ is the smallest integer number $r$ for which the following condition holds\n\n\\begin{equation}\na^r \\text{mod} N_0 = 1 \\tag{1}\n\\end{equation}\n \n\n\n#### Example:\nConsider the case $a=2$ and $N_0=21$, let us find the order of $a$ by trying different exponents $r$ sequentially until \twe find the one for which condition (1) is satisfied:\n\t$2^1 (\\text{mod} 21) = 2$, \n\t$2^2 (\\text{mod} 21) = 4$, \n\t$2^3 (\\text{mod} 21) = 8$, \n\t$2^4 (\\text{mod} 21) = 16$,\n\t$2^5 (\\text{mod} 21) = 11$, \n\t$2^6 (\\text{mod} 21) = 1$.\n\nTherefore, the order of $a=2$ is $r=6$. \n\t\n\n\nNow that we have clarified what is the order of a number, let us explore the connection between order finding and factoring. \nStart by rewriting Eq. (1) as $a^r - 1 \\text{mod} \\, N_0 = 0$, which means that $a^r - 1$ is a multiple of $N_0$. Assuming that $r$ is even, we can write $ a^r - 1 \\text{mod} \\, N_0 = \\left( a^{\\frac{r}{2}} - 1\\right)\\left( a^{\\frac{r}{2}} + 1\\right) \\text{mod} \\, N_0 $. Finally, we check if either $a^{\\frac{r}{2}} - 1$ or $a^{\\frac{r}{2}} + 1$ shares any factors with $N_0$. This can be checked tacking the greatest common divisor (gcd) of them, which outputs the biggest number that divides both inputs. If the output of $\\text{gcd}\\left( a^{\\frac{r}{2}} \\pm 1,N_0 \\right)$ is greater than one, than that's one of the factors. The other one being $N_0/ \\text{gcd}\\left( a^{\\frac{r}{2}} \\pm 1,N_0 \\right)$.\n\n#### Example:\nAgain consider the case $a=2$ and $N_0=21$, in the previous example we found that the order is $r = 6$. Let us now show how to find the two prime factors whose product gives $21$. \n$2^6 - 1 (\\text{mod} \\, 21) = \\left( 2^3 +1 \\right)\\left( 2^3 -1 \\right) (\\text{mod} \\, 21) $.\nWe need to check if the two numbers $ \\left( 2^3 +1 \\right) = 9$ and $ \\left( 2^3 -1 \\right)=7$ have any factors in common with $21$.\nLet's start by checking $ \\left( 2^3 +1 \\right)$: $\\text{gcd}\\left( 9, 21\\right) = 3$.\nWe obtained a $gcd \\neq 1$, which means that there is a common factor between $a^{\\frac{r}{2}} + 1$ and $N_0$. We can now calculate the first factor of $21$.\n$\\text{factor}_1 = \\frac{21}{\\text{gcd}\\left( 9, 21\\right)} = \\frac{21}{3} = 7$.\nThe second factor follows immediately from $\\text{factor}_2 = \\frac{21}{\\text{factor}_1} = \\frac{21}{7} = 3$.\n\nTherefore, we find the two prime factors whose product is $N_0=21$, $\\text{factor}_1 = 7$ and $\\text{factor}_2 = 3$. Thus, the order of $a=2$ is $r=6$. \n\t\n\n\nIt's important to notice that several assumptions are needed to translate the problem of factoring to the one of order finding. These are \"weak points\" of the algorithm, which fails to produce the correct result each time one of these assumptions is violated.\n\n\n## 8.3 Quantum Fourier transform\n\nThe Quantum Fourier Transform (QFT) is the heart of Shor's factoring algorithm. Similarly to the discrete Fourier transform, which allows to compute the Fourier transform of a complex number, the QFT allows to compute the Fourier transform of a quantum state. This means that we can rewrite a generic state of a qubit register as a superposition of all the possible basis state vectors of the register, with a certain phase.\n\nThe QFT of one of the basis states $\\lvert i \\rangle$ of an $n$ qubit register is\n\n\\begin{equation}\nQFT \\lvert j \\rangle = \\frac{1}{2^{n/2}} \\sum_{k=0}^{2^{n}-1} e^{\\frac{2 \\pi i}{2^n} j k} \\lvert k \\rangle\n\\end{equation}\n\nThe QFT on a generic state can then be derived from this definition\n\n\\begin{equation}\nQFT \\sum_{j=0}^{2^n-1} x_j \\lvert j \\rangle = \\sum_{k=0}^{2^{n}-1} \\sum_{l=0}^{2^{n}-1} x_l e^{\\frac{2 \\pi i}{2^n} l k} \\lvert k \\rangle\n\\end{equation}\n\nBy writing the basis state $\\lvert j \\rangle$ in binary representation we adopt the following convention: $\\lvert j_1 j_2 ... j_n \\rangle$ correspond to $j= j_1 2^{n-1}+j_2 2^{n-2} ... j_n 2^{0}$. Following the same convention, we can also write numbers smaller than one as $0.j_1 j_2 ... j_n$ meaning $j_1/2^{0} + j_2/2^{1} +...+ j_n/2^{n}$ a it is possible to rewrite the QFT in a very simple form\n\n\\begin{aligned}\nQFT \\lvert j \\rangle & = \\frac{1}{2^{n/2}} \\sum_{k=0}^{2^{n}-1} e^{2 \\pi i jk / 2^n} \\lvert k \\rangle \\\\\n& = \\frac{1}{2^{n/2}} \\sum_{k_1=0}^{1}...\\sum_{k_n=0}^{1} e^{2 \\pi i \\left(\\sum_{l=1}^{n} k_l 2^{-l}\\right) j} \\lvert k_1 ... k_n \\rangle \\\\\n& = \\frac{1}{2^{n/2}}\\sum_{k_1=0}^{1}...\\sum_{k_n=0}^{1} \\bigotimes_{l=0}^n e^{2 \\pi i j k_l2^{-l} } \\lvert k_l \\rangle \\\\\n& = \\frac{1}{2^{n/2}} \\bigotimes_{l=1}^n \\left(\\lvert 0 \\rangle + e^{2 \\pi i j 2^{-l} } \\lvert 1 \\rangle \\right) \\\\\n& = \\frac{1}{2^{n/2}} \\left( \\lvert 0 \\rangle + e^{2 \\pi i[0.j_n]} \\lvert 1 \\rangle \\right) \\otimes \\left( \\lvert 0 \\rangle + e^{2 \\pi i[0.j_{n-1} j_{n}]} \\lvert 1 \\rangle \\right) \\otimes ...\\otimes \\left(\\lvert 0 \\rangle + e^{2 \\pi i[0.j_1j_2...j_{n-1}j_n]} \\lvert 1 \\rangle \\right)\n\\end{aligned}\n\nBy writing the QFT in this way, it is easy to find a circuit which implements it. The QFT turns out to be composed of very simple gates such as Hadamard and control-rotations around the z-axis between pairs of qubits $CR_k$.\n\n$$ CR_k =\n\\begin{pmatrix} \n1 & 0 & 0 & 0 \\\\\n0 & 1 & 0 & 0 \\\\ \n0 & 0 & 1 & 0 \\\\ \n0 & 0 & 0 & e^{2 \\pi i/ 2^k}\n\\end{pmatrix}$$\n\n\n$$\\text{1. Quantum circuit for the Quantum Fourier Transform.}$$\n\n\n#### Example: QFT on two qubits\nLet us calculate the QFT in the case of $n=2$ qubits\n\n$$QFT\\lvert j_1j_2\\rangle = \\frac{1}{\\sqrt{8}} \\left(\\lvert 0 \\rangle + e^{2 \\pi i[0.j_2]} \\lvert 1 \\rangle\\right) \\otimes \\left(\\lvert 0 \\rangle + e^{2 \\pi i[0.j_1 j_2]} \\lvert 1 \\rangle \\right) $$\n\nThe steps to creating the circuit for $\\lvert k_1k_2\\rangle = QFT\\lvert j_1j_2\\rangle$ would be:\n\n\n \nApply an Hadamard to $\\lvert j_2 \\rangle$, giving the state $\\frac{1}{\\sqrt{2}}\\left(\\lvert 0 \\rangle + e^{2 \\pi i 0.j_2} \\lvert 1\\rangle\\right) = \\frac{1}{\\sqrt{2}}\\left(\\lvert 0 \\rangle + (-1)^{j_2} \\lvert 1 \\rangle\\right)$\n \n\n \nApply a $CR_2$ from $\\lvert j_1 \\rangle$ to $\\lvert j_2 \\rangle$ and an Hadamard to $\\lvert j_1 \\rangle$, giving the state $\\frac{1}{\\sqrt{2}}\\left(\\lvert0\\rangle + e^{2 \\pi i[0.j_1j_2]} \\lvert1\\rangle\\right)$\n \n\n \nMeasure the qubits in reverse order, that is $k_2$ corresponds to the first qubit, $k_1$ to the second qubit.\n \n \n\n\n$$\\text{2. Quantum Fourier Transform for two qubits.}$$\n\n\n```python\n# QISKIT: QFT code \n\n# calculate qft of two qubit as the example above\n```\n\n### QISKit: implement the quantum Fourier transform \n\n#### 1) Fourier transform of two qubits in the $\\lvert 00 \\rangle $ state \n\n\n```python\nfrom initialize import *\n\ndef qft(circ, q, n):\n \"\"\"n-qubit QFT on q in circ.\"\"\"\n for j in range(n):\n for k in range(j):\n circ.cu1(3.14/float(2**(j-k)), q[j], q[k])\n circ.h(q[j])\n\n#initialize quantum program\nmy_alg = initialize(circuit_name = 'fourier', qubit_number=2, bit_number=2, backend = 'local_qasm_simulator', shots = 1024)\n\n#add gates to the circuit\nqft(my_alg.q_circuit, my_alg.q_reg, 2) # qft of input state\nmy_alg.q_circuit.measure(my_alg.q_reg[0], my_alg.c_reg[0]) # measures first qubit\nmy_alg.q_circuit.measure(my_alg.q_reg[1], my_alg.c_reg[1]) # measures second qubit\n\n# print list of gates in the circuit\nprint('List of gates:')\nfor circuit in my_alg.q_circuit:\n print(circuit.name)\n\n#Execute the quantum algorithm\nresult = my_alg.Q_program.execute(my_alg.circ_name, backend=my_alg.backend, shots= my_alg.shots)\n\n#Show the results obtained from the quantum algorithm \ncounts = result.get_counts(my_alg.circ_name)\n\nprint('\\nThe measured outcomes of the circuits are:',counts)\n\n# credits to: https://github.com/QISKit/qiskit-tutorial\n```\n\n List of gates:\n h\n cu1\n h\n measure\n measure\n \n The measured outcomes of the circuits are: {'00': 243, '01': 241, '10': 272, '11': 268}\n\n\n## 8.4 Description of the algorithm\n\n\nShor's algorithm exploits both classical and quantum computation. Classical operations are carried out in steps where an efficient classical algorithm exists, while quantum operations are used to find the periodicity of the function needed to factor $N_0$. Here we present an outline of the algorithm.\n\n\n$$\\text{3. Quantum circuit for Shor's algorithm.}$$\n\n\nTo run the algorithm, we need two quantum registers. One contains the order or period, called period register, and the other contains the results of the computation, called computational register. The size of both registers depends on the number $N_0$ to be factored. In particular, the period register should contain a number of qubits $n_p$ in the interval $2 \\text{log} N_0 \\leq n_p < 2 \\text{log} (2N_0) $ and the computational register should be large enough to be able to represent the number $N_0-1$, thus $n_q = \\text{log} (N_0-1)$.\n\nFirst, one needs to check if $N_0$ is even. If $N_0$ is even, one of the factor is $2$ and the other is $N_0/2$. \n\n\n\nIf $N_0$ is odd, a base $a$ is picked randomly among the numbers from $0$ to $N_0-1$. Then, check if $a$ is a factor of $N_0$, by checking if gcd$\\left(a,N_0 \\right) \\neq 1$. If $a$ is has a common divisor with $N_0$, then one factor is given by gcd$\\left(a,N_0 \\right)$ and the other by $N_0/$gcd$\\left(a,N_0 \\right)$. If $a$ is co-prime with $N_0$ ( gcd$\\left(a,N_0 \\right) = 1$ ) then one needs to compute the function $a^x$ mod $N_0$, the modular exponentiation function (MEF), for $x=1,2,3,..Q-1$ where $N_0^2 \\leq Q < 2N_0^2$ and $Q=2^{n_p}$. \n\nAt the beginning of the quantum algorithm used to compute the MEF we need two registers initialized to zero $\\lvert 00...0 \\rangle \\lvert 00...0 \\rangle $. The first register also known as the period register will stores all the possible values of the exponent $x$ by creating a uniform superposition of all possible bit strings through Hadamard gates on all qubits $\\frac{1}{\\sqrt{Q}} \\sum_{x=0}^{Q-1} \\lvert x \\rangle $, and the second register, called the computational register will store the results of the MEF $a^x$ mod $N_0$, $\\lvert a^x $ mod $ N_0 \\rangle$. Thus, after the first step, one has\n\n\\begin{equation}\n\t\\frac{1}{\\sqrt{Q}} \\sum_{x=0}^{Q-1} \\lvert x \\rangle \\lvert a^x mod N_0 \\rangle\n\\end{equation}\n\nThen, we apply the quantum Fourier transform (QFT) to the first register, so that $\\lvert x \\rangle \\rightarrow \\frac{1}{\\sqrt{Q}} \\sum_{s=0}^{Q-1} e^{\\frac{2\\pi i s x}{Q}}\\lvert s \\rangle$. As a result of the QFT, interference between all the possible states occurs and only the periodic ones survive. That is, if one measures the first register, one will see a value of $s$ such that $\\frac{sx}{Q}$ is an integer $d$ when $x$ a multiple of the period $r$. Which means that $\\frac{s}{Q}=\\frac{d}{r}$. By knowing the fraction $\\frac{s}{Q}$ one can find the value of $r$ through the continued fraction algorithm.\nNow, if $r$ is odd or $r=0$, the algorithm fails and one needs to restart by picking a different base $a$. If $r$ is even, one can factorize $a^r - 1$ mod $N_0$ into $\\left( a^{\\frac{r}{2}} - 1\\right)\\left( a^{\\frac{r}{2}} + 1\\right)$ mod $N_0$. The final step is to check if $a^{\\frac{r}{2}} + 1 \\, \\text{mod} \\, N_0 \\neq -1$. If that's true, then $\\text{gcd}\\left(a^{\\frac{r}{2}} + 1,N_0 \\right)$ will be the first factor and $\\text{gcd}\\left(a^{\\frac{r}{2}} - 1,N_0 \\right)$ the other.\n\n\nThe execution of this version of the algorithm requires $n=log_2 \\left( N_0 \\right)$ qubits in the computational register to perform the modular exponentiation and another $2n$ qubits in the period register to perform the QFT. Thus, the algorithm requires a total number of $3n$ qubits.\n\n## 8.5 Example of Shor's factoring algorithm\n\nLet us see here an example of Shor's factoring algorithm for $N_0=21$. Since $21$ needs five bits to be represented in binary, we need at least $\\text{log}_2Q = 2*5$ qubits for factoring. \n\n\n \n Check if $N_0=21$ is even: $21 \\, \\text{mod} \\, 2=1$, $N_0$ is not even. \n \n Pick a base $a$ at random. Let's say $a=2$. \n \n Check if $a$ has any common factors with $N_0$: $\\text{gcd}\\left(a,N_0 \\right) = 1$, it doesn't. \n \n Initialize two qubit registers with $n_p = 2\\times5=10$ qubits, as $5$ qubits are needed to represent $21$ in binary. We call the first register the $period$ register and the second register the $computational$ register\n $$ \\lvert \\psi \\rangle = \\lvert 0 \\rangle^{\\otimes 10}_p \\lvert 0 \\rangle^{\\otimes 10}_c $$ \n \n Apply Hadamard gate on all ther qubits of the first register to create a uniform superposition of all $2^{10}$ possible values \n $$ \\lvert \\psi \\rangle =\\frac{1}{\\sqrt{2^{10}}} \\sum_{x=0}^{2^{10}-1} \\lvert x \\rangle_p \\lvert 0 \\rangle_c $$ \n \n Apply the modular exponentiation function $a^x \\, \\text{mod} \\, N_0$ on the second register, for each of the stored value of $x$ in the first register.\n \n$$ \\lvert \\psi \\rangle =\\frac{1}{\\sqrt{1024}} \\sum_{x=0}^{1023} \\lvert x \\rangle_p \\lvert 2^x \\, \\text{mod} \\, 21 \\rangle_c\n = \\\\ = \\frac{1}{\\sqrt{1024}} \\left( \\lvert 0 \\rangle_p \\lvert 1 \\rangle_c + \\lvert 1 \\rangle_p \\lvert 2 \\rangle_c + \\lvert 2 \\rangle_p \\lvert 4 \\rangle_c + \\lvert 3 \\rangle_p \\lvert 8 \\rangle_c + \\lvert 4 \\rangle_p \\lvert 16 \\rangle_c + \\lvert 5 \\rangle_p \\lvert 11 \\rangle_c + \\lvert 6 \\rangle_p \\lvert 1 \\rangle_c + \\lvert 7 \\rangle_p \\lvert 2 \\rangle_c + \\lvert 8 \\rangle_p \\lvert 4 \\rangle_c ... \\right) $$\n By looking at the values stored in the second register, we can find out what is their periodicity. In particular, it can be seen that the values start repeating with order $r=6$ (value of the first register). However, we need to do a few more steps to allow the quantum computer to find the answer by itself. \n \n To simplify the example, we will adopt the \"Principle of implicit measurement\": Without loss of generality, any qubits which are not measured at the end of the quantum circuit may be assumed to be measured. Thus, let us use the principle of implicit measurement on the second register. Since each term of the superposition has equal weight, each outcome is equally likely, therefore one will see one of the following values: $ \\lvert 1 \\rangle_c$ , $\\lvert 2 \\rangle_c$, $ \\lvert 4 \\rangle_c$, $\\lvert 8 \\rangle_c$, $\\lvert 16 \\rangle_c$, $\\lvert 11 \\rangle_c$; with probability $1/6$.\n Assume that the state $ \\lvert 4 \\rangle_c$ is measured, then we are left with the composite state:\n \n $$ \\lvert \\psi \\rangle = \\frac{\\sqrt{6}}{\\sqrt{1024}} \\left( \\lvert 2 \\rangle_p \\lvert 4 \\rangle_c + \\lvert 8 \\rangle_p \\lvert 4 \\rangle_c + \\lvert 14 \\rangle_p \\lvert 4 \\rangle_c + \\lvert 20 \\rangle_p \\lvert 4 \\rangle_c ... \\right) $$ \n \n Apply the QFT to the first register\n $$ \\lvert x \\rangle_p \\rightarrow \\frac{1}{\\sqrt{1024}} \\sum_{s=0}^{1023} e^{2\\pi i \\frac{s x}{1024}}\\lvert s \\rangle_p $$\n Which transform each of the terms in the period register as:\n $$ \\lvert 2 \\rangle_p \\rightarrow \\frac{1}{\\sqrt{1024}} \\sum_{s=0}^{1023} e^{2\\pi i \\frac{2 s}{1024}}\\lvert s \\rangle_p $$\n $$ \\lvert 8 \\rangle_p \\rightarrow \\frac{1}{\\sqrt{1024}} \\sum_{s=0}^{1023} e^{2\\pi i \\frac{8 s}{1024}}\\lvert s \\rangle_p $$\n $$ \\lvert 14 \\rangle_p \\rightarrow \\frac{1}{\\sqrt{1024}} \\sum_{s=0}^{1023} e^{2\\pi i \\frac{14 s}{1024}}\\lvert s \\rangle_p $$\n $$ \\lvert 20 \\rangle_p \\rightarrow \\frac{1}{\\sqrt{1024}} \\sum_{s=0}^{1023} e^{2\\pi i \\frac{20 s}{1024}}\\lvert s \\rangle_p $$\n $$...$$\n \n So, we can write:\n $$ \\lvert \\psi \\rangle = \\frac{\\sqrt{6}}{1024} \\sum_{s=0}^{1023} \\left( e^{2\\pi i \\frac{2s}{1024}} + e^{2\\pi i \\frac{8s}{1024}} + e^{2\\pi i \\frac{14s}{1024}} + e^{2\\pi i \\frac{20s}{1024}} ... \\right) \\lvert s \\rangle_p \\lvert 4 \\rangle_c = \\\\\n = \\frac{\\sqrt{6}}{1024} \\sum_{s=0}^{1023} e^{2\\pi i \\frac{2s}{1024}} \\left( 1 + e^{2\\pi i \\frac{6s}{1024}} + e^{2\\pi i \\frac{12s}{1024}} + e^{2\\pi i \\frac{18s}{1024}} ... \\right) \\lvert s \\rangle_p \\lvert 4 \\rangle_c$$\n \n\n Measure the period register. The probability of finding a certain value $\\lvert s \\rangle_p$ is:\n $$ P(s) = \\lvert \\frac{\\sqrt{6}}{1024} e^{2\\pi i \\frac{2s}{1024}} \\left( 1 + e^{2\\pi i \\frac{6s}{1024}} + e^{2\\pi i \\frac{12s}{1024}} + e^{2\\pi i \\frac{18s}{1024}} ... \\right) \\rvert^2 $$\n \n Because of the possible sign difference between all different terms, the values of $s$ which have the highest likelyhood to be observed are the ones for which the phase terms all have the same sign and they add up. That is, $\\frac{s}{1024}=\\frac{d}{6}$, where $d$ is an integer. Therefore, a value $s=\\frac{1024 \\cdot d}{6}$ where $d=1,2,3,...$ will most likely be observed.\n Let us assume that the value $s=853$ is measured.\n \n\n To find the period from the value of $s$ measured, one then uses the continued fraction algorithm in the following way: we find the fraction $\\frac{d}{r}$ which approximates the fraction $\\frac{s}{Q}$ to a fixed precision $2*Q$\n $$\\lvert \\frac{853}{1024} - \\frac{d}{r} \\rvert < \\frac{1}{2048} $$\n So, let's find $d$ and $r$ with the continued fraction algorithm:\n $$ \\frac{853}{1024} = 0 + \\frac{1}{1 + \\frac{1}{4+ \\frac{1}{1+\\frac{1}{1+\\frac{1}{1+\\frac{1}{84+\\frac{1}{2}}}}}}} $$\n which gives as possible fractions $\\frac{d}{r}$: $\\frac{1}{1}$, $\\frac{4}{5}$, $\\frac{5}{6}$, ...\n \n imposing the condition written above, we find that the only fraction satisfying it is $\\frac{d}{r} = \\frac{5}{6}$. Therefore, the period is $r=6$!\n \n \n Once the period has been found, we can find the factors of $N_0=21$ almost immediately. First check if $r$ is even then check if $a^{\\frac{r}{2}} + 1 \\, \\text{mod} \\, N_0 \\neq -1 $ :\n $$ 6 \\, \\text{mod} \\, 2 = 0 $$\n $$ 2^{\\frac{6}{2}} + 1 \\, \\text{mod} \\, 21 = 9$$\n Therefore the two factors are: $ p = \\text{gcd}\\left(a^{\\frac{r}{2}} + 1,N_0 \\right)$ and $q = \\text{gcd}\\left(a^{\\frac{r}{2}} - 1,N_0 \\right)$\n $$p = \\text{gcd}\\left(9,21 \\right) = 3$$\n $$q = \\text{gcd}\\left(7,21 \\right) = 7$$\n \n\n \n\n \n\n## Exercises\n\n\n\n\nCalculate the following modular expression:\n\n\n\n$ 54 \\, \\text{(mod 5)}$\n \n\n$ 54 \\times 35 \\, \\text{(mod 17)}$\n \n\n$ 9^{2} \\, \\text{(mod 6 )}$\n \n \n \n\n\nRewrite the following fractions using the continued fraction algorithm\n\n\n\n$ \\frac{45}{251}$\n \n\n$ \\frac{71}{385}$\n \n\n$ \\frac{512}{1027}$\n \n \n\n \n\n\nWhat is the minimum number of qubits needed to factor:\n\n\n\n$ 15 $\n \n\n\n$ 4,367,398 $\n \n \n\n \n\n\nDerive the expression of the Quantum Fourier Transform of three qubits, similarly to how it is done in the example shown in Section 8.3\n\n \n\n\nFollowing the steps highlighted in the example given in Section 8.5, show the factoring of $N_0=15$ with $a=2$.\n \n\n\nWrite a QISKit program that calculates the QFT of three qubits in the state $\\lvert 010 \\rangle$ .\n \n\n\n \n\n## References\n\n\n[1] P. Shor, in Proc. 35th Annu. Symp. on the Foundations of\nComputer Science, edited by S. Goldwasser (IEEE Computer\nSociety Press, Los Alamitos, California, 1994),\np. 124-134.\n\n\n[2] L. M. K. Vandersypen, M. Steffen, G. Breyta, C. S. Yannoni,\nM. H. Sherwood, and I. L. Chuang, Nature 414,\n883 (2001).\n\n[3] Monz, T. et al., Science 351, 1068-1070 (2016).\n\n\n[4] C. Y. Lu, D. E. Browne, T. Yang, and J. W. Pan, Physical\nReview Letters 99, 250504 (2007).\n\n[5] E. Martin-Lopez, A. Laing, T. Lawson, R. Alvarez, X.-Q.\nZhou, and J. L. O'Brien, Nat Photon advance online publication (2012).\n\n[6] Lanyon, B. P. et al., Phys. Rev. Lett. 99, 250505 (2007).\n\n[7] A. Politi, J. C. F. Matthews, and J. L. O' Brien, Science 25, 1221 (2009).\n\n[8] E. Lucero, R. Barends, Y. Chen, J. Kelly, M. Mariantoni, A. Megrant, P. O'Malley, D. Sank, A. Vainsencher, J. Wenner, T. White, Y. Yin, A. N. Cleland and John M. Martinis, Nature Physics volume 8, 719-723 (2012).\n\n[9] P. J. Coles et al. (2018), arXiv:1804.03719.\n\n[10] J. A. Smolin, G. Smith, and A. Vargo, Nature (London) 499, 163-165 (2013).\n\n", "meta": {"hexsha": "ebf24f5b2b06dfad840d200b8efbd83a7fd16c17", "size": 32728, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "awards/teach_me_quantum_2018/intro2qc/8.Shor's algorithm.ipynb", "max_stars_repo_name": "YumaNK/qiskit-community-tutorials", "max_stars_repo_head_hexsha": "491fbb7ef1f99772d25eb6eacb4340ef1ac75253", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 293, "max_stars_repo_stars_event_min_datetime": "2020-05-29T17:03:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T07:09:50.000Z", "max_issues_repo_path": "awards/teach_me_quantum_2018/intro2qc/8.Shor's algorithm.ipynb", "max_issues_repo_name": "YumaNK/qiskit-community-tutorials", "max_issues_repo_head_hexsha": "491fbb7ef1f99772d25eb6eacb4340ef1ac75253", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 30, "max_issues_repo_issues_event_min_datetime": "2020-06-23T19:11:32.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-20T22:25:54.000Z", "max_forks_repo_path": "awards/teach_me_quantum_2018/intro2qc/8.Shor's algorithm.ipynb", "max_forks_repo_name": "YumaNK/qiskit-community-tutorials", "max_forks_repo_head_hexsha": "491fbb7ef1f99772d25eb6eacb4340ef1ac75253", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 204, "max_forks_repo_forks_event_min_datetime": "2020-06-08T12:55:52.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T08:37:14.000Z", "avg_line_length": 58.6523297491, "max_line_length": 746, "alphanum_fraction": 0.5821009533, "converted": true, "num_tokens": 8672, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.5, "lm_q2_score": 0.20946968379784037, "lm_q1q2_score": 0.10473484189892018}}
{"text": "# 1. Chapter 1 - Plausible Reasoning\nAs we tread further into the twenty first century, almost everyone is expected to memorize the mantra \"we must make data driven decisions\" (well, at least most people in the technology space, and certainly data scientists). However, I want us to pause for a moment and think about what that really means?\n\nIn an idealized, rigid, platonic world this may simply mean to cast our first intuitions aside, instead using metrics related to the problem at hand, past decision's outcomes, and so on. Now, in a simplistic system this is a satisfactory approach. Consider the following (overly simple) scenario; you want to figure out the fastest way to drive from your house to the grocery store at rush hour (note how _constrained_ this situation already is). You intuitively feel as though route $A$ will be faster, so in general you take that route. You know that on average it takes about 9 minutes. Then, one day your roommate decides to join you and recommends route $B$, stating that they always drive that way and that on average it takes 6 minutes. You give route $B$ a shot an sure enough it takes 6 and half minutes. \n\nThis is an example of a very simplistic scenario that is conducive to basic data driven decision making. You have (essentially) all the data/variables you need in order to represent the scenario at hand. In other words, the decision is based on a univariate function:\n\n$$\\text{Time spent driving to grocery story} = f(\\text{route})$$\n\nWe have data regarding driving time of both routes, and in this toy example there is really nothing else we need to consider in order to make an optimal decision that reduces driving time. \n\nIt should be no surprise that this is _not_ how things work in the real world. The real world is messy, contains an abundance of variables, and these variables manifest into **uncertainty**. The question that I have become obsessed with is as follows:\n\n> How can we reason optimally in complex and uncertain situations? \n\nFor instance, let's now say that your company sells widgets. You, as a person in marketing, are in charge of coming up with sales offerings around the holiday season. Your initial intuition is that if you give out 20 dollar coupons to anyone who makes a purchase, you will get more purchases. However, there is a competing hypothesis from your colleague that suggests offering a discount to customers who make over 1000 dollar in purchases would actually be more effective at generating revenue. You have some historical time series data, but _neither_ have specifically been conditioned upon the exact hypotheses you are both proposing (i.e., you have no data that was collected during a 20 dollar coupon period, or during a 1000 dollar purchase discount period). The data that you have is necessarily incomplete, and even if it wasn't we still must confront the following logical problem:\n\n> How do we use data (frequencies of events) to estimate plausibilities of beliefs?\n\nIn other words, how can we use the data present to estimate how plausible on hypothesis is compared to the other? This question is the central focus of _Probability Theory: The Logic of Science_, by E.T. Jaynes. Often viewed as the first text to make probability theory a \"hard\" branch of mathematics (compared to a group of ad hoc methods), it is an incredibly ambitious and thought provoking book that should be on any data scientist's or statistician's bookshelf. With that said, at times it is rather dense, and I wanted to take the time to create a set of articles that serve as chapter summaries. Note, these do not mean to replace the original text; rather, they can be read in tandem to clear up any sources of confusion and ensure clear understanding. \n\nWith that said, let's begin digging into the book, starting with the preface and chapter 1.\n\n## 0.1 Preface\nJaynes starts the book by stating who the intended audience is; while this is generally not very informative, here it actually has a good deal of merit! He states that the material is meant to help those who are in fields such as physics, chemistry, biology, geology, medicine, economics, sociology, engineering, operations research, etc.; any field where **inference** is needed. He adds a footnote stating that by inference he means:\n\n> **Inference:** **Deductive** reasoning whenever enough information is at hand to permit it; **inductive** or _plausible_ reasoning when the necessary information is not available (as it almost never is in real problems). If a problem can be solved with deductive reasoning, probability theory is not needed for it. Thus, the topic of this book is **the optimal processing of incomplete information**.\n\nAs a data scientist this type of footnote should send tingles down your spine. In nearly every situation you will encounter you are often treading the line of making inferences based off of a combination of deductive and inductive reasoning; who wouldn't want to be making those inferences in an optimal way? \n\nNow, for those unfamiliar with the concepts of deduction and induction I recommend checking out this section of my article on Bayesian Inference. But, for a quick recap we can think of **deduction** as forming some hypothesis about the state of the world or it's workings, gathering data about that state, and then seeing if our data confirms or denies our hypothesis. It can be visualized below:\n\n\n\nThat is deduction. We perform deduction every day with relative ease. On the other hand we have **induction**, which works in the opposite direction:\n\n\n\nHere, we gather data about the world around us, and after picking up on a pattern we induce a hypothesis, and then work towards concluding it's validity. Now, it should be noted that this idea of reasoning from evidence to hypothesis can be thought of as a parallel of reasoning from effect to cause. \n\nAs a small example (that I came across when reading _The Book of Why_ by Judea Pearl, consider Sherlock Holmes. Imagine that Sherlock Holmes was called to investigate a broken window. Sure he could go about it deductively and, while driving to the location of the window (i.e. before gathering any data), generate the hypothesis that the it was a group of children who broke the window. This is what humans do with ease, daily. However, what truly made Sherlock Holmes so powerful was his ability to perform induction. In this case, he arrives at the scene of the broken window, sees glass scattered about, and surely a host of other interesting things; he takes all of this _data_ and then generates a hypothesis about how the window was broken. \n\nIf that example leads you to feel slightly intimidated by the process of induction, do not worry! Without digging into it too deeply, there is actually an _asymmetry_ going on here that can lead you into _chaos theory_. For this I will borrow another example, this time from Nassim Taleb. Imagine that you want to understand what happens when you leave a block of ice out at room temperature. You hypothesize that it will melt (form your hypothesis). You then take 10 blocks of ice, leave them all out at room temperature, and see that they do indeed all melt (collect data). You just performed a very straight forward deduction, making use of what is referred to as the **forward process**. \n\nConsider the inverse case now. Imagine that you walk into your kitchen and see that there is a puddle of water on the ground. You try and gather data, seeing if there is a leak in a pipe anywhere, if a cup spilled, etc. There is an incredibly long list of ways that this water could have gotten there. Trying to determine (from what is most likely incomplete data) that the water is actually there due to a block of ice that melted, is incredibly challenging. This is known as the **backward process**. If you are interested in this type of problem I recommend looking at the [Butterfly Effect](https://en.wikipedia.org/wiki/Butterfly_effect); for now I will leave it here to prevent going down a rabbit hole. \n\n### 0.2 The Theme of the Book\nTo give us a north star to focus on, I want to take a moment to highlight what is essentially the theme of the book:\n\n> **Probability theory as extended logic**.\n\nWe will dig into this much further in subsequent posts, but what this book does is create a framework in which the rules of probability theory can be viewed as uniquely valid principles of _logic_ in general, leaving out reference to _chance_ or _random variables_. This allows for the imaginary distinction between probability theory and statistical inference to disappear, allowing logical unity as well as greater technical power. \n\nThis theme amounts to recognition that the mathematical rules of probability theory are not merely rules for calculating frequencies of \"random variables\"; they are also the unique and consistent rules for conducting inference (i.e. plausible reasoning) of any kind. \n\nThis set of rules will automatically include all **Bayesian** calculations, as well as all **frequentist** calculations. Never the less, our basic rules are broader than either of these, and in many applications the calculations will not fit into either category. As explained by Jaynes:\n\n> The traditional frequentist methods which only use sampling distributions are usable and useful in particularly simple, idealized problems; however, the represent the most proscribed cases of probability theory, because they presuppose conditions (independent repetitions of a 'random experiment' but no relevant prior information) that are hardly ever met in real problems. This approach is quite inadequate for the current needs of science. \n\nJaynes proceeds to dig into the idea of **prior** information/knowledge, and how it is essential that it is included in data analysis and inference. He writes that a false premise built into a model which is never questioned cannot be removed by any amount of new data. The use of models which correctly represent the prior information that scientists have about the mechanism at work can prevent such folly in the future. By ignoring prior information we not only set ourselves up to fail in the inference we are trying to make, but we also risk stalling out scientific progression itself. _No amount of analyzing coin tossing data by a stochastic model could have led us to the discovery of Newtonian Mechanics, which alone determines those data_. \n\nWith our stage set we are ready to dive into what is one of the most thought provoking and eye opening books in the realm of mathematics and science. Enter chapter 1. \n\n# 1. Chapter 1: Plausible Reasoning\nSuppose that on some dark night a policeman walks down a street, apparently deserted. Sudddenly he hears a burglar alarm, looks across the street, and sees a jewelry store with a broken window. Then a gentleman wearing a mask comes crawling through the broken window, carrying a bag which turns out to be full of expensive jewelry. The policeman doesn't hesitate at all in deciding that this gentleman is dishonest. But the question is: **By what reasoning process does he arrive at this conclusion?**\n\n#### 1.1 Deductive and Plausible Reasoning\nKeep in mind the key theme of this book, these articles, and more importantly data science in general: _How can we reason optimally in complex and uncertain situations?_ It may seem as though this preface and introduction get slightly into the weeds; this is a book on probability after all, right? Jaynes goes to great length to work through the _philosophy_ behind this vantage point of probability (seen as extended logic instead of based off of the standard Kolmogorov axioms); it is not unreasonable to ask why. The key lies in the fact that Jaynes is not simply trying to replace one axiomatic framework with another, but rather he is trying to build up a way to _reason_ consistently and logically, and apply that reasoning to any area of inference. I recommend taking a moment to appreciate that and let it sink in. Many of the problems that Jaynes works this in the forthcoming chapters could have been solved with standard orthodox or bayesian statistics; what makes this framework so powerful is that it provides a way to _reason consistently_. You are not required to hold in your head a bag of ad hoc methods and techniques. Rather, you have a methodology that allows you to approach and reason about any problem logically and consistently. Surely this is what any scientifically minded problem solver would hope for! \n\nWith that said let's return to our problem. A bit of thought makes it clear that the policeman's conclusion was not a logical deduction from the evidence; there may have been a perfectly reasonable explanation for everything! For instance, it is certainly _possible_ that the man was the owner of the jewelery store and was coming home from a masquerade party, and as he passed his store some teenagers threw a rock at the window, and he was simply trying to protect his property. \n\nSo, clearly the policemans reasoning process was not strictly logical deduction. However, we can grant that it did possess a high degree of validity. The evidence did not make the gentleman's dishonesty _certain_, but it did make it extremely _plausible_. This is the type of reasoning that humans have become proficient with long before studying mathematical theories. We encounter an abundance of these decisions daily (will it rain or won't it?) where we do not have enough information to permit deductive reasoning; but still we must decide immediately what to do. \n\nNow, inspite of how familiar this process is to all of us, the formation of plausible conclusions is very subtle. This book allows us to replace intuitive judgements with definite theorems, and ad hoc procedures are replaced by rules that are determined uniquely by some elementary and inescapable criteria of rationality. \n\nNow, let's take a moment to try and place this within the context of aristotelian logic; that is the most appropriate starting point to dissect the difference between **[deductive reasoning](https://en.wikipedia.org/wiki/Deductive_reasoning)** and **plausible reasoning**. \n\n#### Deductive Reasoning\nDeductive reasoning is defined as the process of reasoning from one or more **statements** (premises) in order to reach a logically certain conclusion. We can think of deductive reasoning as follows:\n\n1. All men are mortal. (First premise)\n2. Socrates is a man. (Second premise)\n3. Therefore, Socrates is mortal. (Conclusion)\n\nAnd this is defined mathematically below (known as **[modus ponens](https://en.wikipedia.org/wiki/Deductive_reasoning#Modus_ponens)**, the law of detachment): \n\n$$\n\\begin{equation}\n\\text{If A is true, then B is true} \\\\\n\\frac{\\text{A is true}}\n{\\text{therefore, B is true}}\n\\end{equation}\n$$\n\nIt is the primary deductive rule of inference. An example would be:\n1. If it is raining, then there are clouds in the sky.\n2. It is raining.\n3. Therefore, there are clouds in the sky.\n\nThere is also the inverse (known as **[modus tollens](https://en.wikipedia.org/wiki/Deductive_reasoning#Modus_tollens)**, the law of contrapositive), another deductive rule of inference:\n\n$$\n\\begin{equation}\n\\text{If A is true, then B is true} \\\\\n\\frac{\\text{B is false}}\n{\\text{therefore, A is false}}\n\\end{equation}\n$$\n\nAnd we have the counter simple example:\n1. If it is raining, then there are clouds in the sky.\n2. There are no clouds in the sky.\n3. Thus, it is not raining.\n\nBoth of the above are known as **strong syllogisms**. Now in general, Deductive reasoning (\"top-down logic\") contrasts with inductive reasoning (\"bottom-up logic\") in the following way; in deductive reasoning, a conclusion is reached reductively by applying general rules which hold over the entirety of a closed domain of discourse, narrowing the range under consideration until only the conclusion(s) is left. In inductive reasoning, the conclusion is reached by generalizing or extrapolating from specific cases to general rules, i.e., there is epistemic uncertainty (for example the black swan). However, the inductive reasoning mentioned here is not the same as induction used in mathematical proofs – mathematical induction is actually a form of deductive reasoning.\n\n\n```javascript\n%%javascript\nMathJax.Hub.Config({\n TeX: { equationNumbers: { autoNumber: \"AMS\" } }\n});\n```\n\n\n \n\n\n\n```python\n\n```\n", "meta": {"hexsha": "9169e4748da8a481f6d91a91b1962f6cf4fde708", "size": 18946, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/07-Probability_Theory,_The_Logic_of_Science-01-Chapter-1.ipynb", "max_stars_repo_name": "NathanielDake/nathanieldake.github.io", "max_stars_repo_head_hexsha": "82b7013afa66328e06e51304b6af10e1ed648eb8", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2018-03-30T06:28:21.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-25T15:43:24.000Z", "max_issues_repo_path": "Mathematics/07-Probability_Theory,_The_Logic_of_Science-01-Chapter-1.ipynb", "max_issues_repo_name": "NathanielDake/nathanieldake.github.io", "max_issues_repo_head_hexsha": "82b7013afa66328e06e51304b6af10e1ed648eb8", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Mathematics/07-Probability_Theory,_The_Logic_of_Science-01-Chapter-1.ipynb", "max_forks_repo_name": "NathanielDake/nathanieldake.github.io", "max_forks_repo_head_hexsha": "82b7013afa66328e06e51304b6af10e1ed648eb8", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-02-07T22:21:33.000Z", "max_forks_repo_forks_event_max_datetime": "2018-05-04T20:16:43.000Z", "avg_line_length": 98.1658031088, "max_line_length": 1340, "alphanum_fraction": 0.7331890637, "converted": true, "num_tokens": 3524, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.45326184801538616, "lm_q2_score": 0.23091975234373585, "lm_q1q2_score": 0.104667113690577}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ntag = HTML('''\nPromijeni vidljivost ovdje .''')\ndisplay(tag)\n```\n\n\n\nPromijeni vidljivost ovdje .\n\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nfrom scipy.integrate import odeint\nimport matplotlib.pyplot as plt\nimport ipywidgets as widgets\n```\n\n## Linearizacija - Jednostavno njihalo\n\nPri radu s modelima sustava, linearizacija je postupak modeliranja nelinearnog sustava s linearnom diferencijalnom jednadžbom u susjedstvu neke radne točke (obično točke ravnoteže). U ovom primjeru taj je postupak demonstriran pomoću jednostavnog njihala. Sila koja uzrokuje oscilacijsko gibanje njihala (prikazano na donjoj slici) definirana je kao $-mgsin\\theta$. Jednadžba gibanja njihala definirana je kao:\n\n\\begin{equation}\n mL^2\\frac{d^2\\theta}{dt^2}=-mgsin\\theta L.\n\\end{equation}\n\nNakon sređivanja dobivamo sljedeću nelinearnu diferencijalnu jednadžbu drugog reda:\n\n\\begin{equation}\n \\frac{d^2\\theta}{dt^2}+\\frac{g}{L}sin\\theta=0.\n\\end{equation}\n\nU slučaju malih kutnih pomaka, vrijedi aproksimacija malog kuta (i.e. $sin\\theta\\approx\\theta$) i dobiva se sljedeća linearna diferencijalna jednadžba drugog reda:\n\n\\begin{equation}\n \\frac{d^2\\theta}{dt^2}+\\frac{g}{L}\\theta=0.\n\\end{equation}\n\n---\n\n\n \n Jednostavno njihalo \n \n \n \n \n \n
\n\n### Kako koristiti ovaj interaktivni primjer?\n\nPomičite klizače za promjenu duljine njihala $L$ i vrijednosti početnih uvjeta $\\theta_0$ i $\\dot{\\theta_0}$.\n\n\n```python\n# create figure\nfig = plt.figure(figsize=(9.8, 3),num='Diskretizacija - jednostavno njihalo')\n\n# add sublot\nax = fig.add_subplot(111)\nax.set_title('Vremenski odziv')\nax.set_ylabel('izlaz')\nax.set_xlabel('$t$ [s]')\nax.axhline(y=0, xmin=-1, xmax=6, color='k', linewidth=1)\n\nax.grid(which='both', axis='both', color='lightgray')\n\nnonlinear, = ax.plot([], [])\nlinear, = ax.plot([], [])\n\nstyle = {'description_width': 'initial'}\n\ng=9.81 # m/s^2\n\ndef model_nonlinear(ic,t,L):\n fi, fidot = ic\n return [fidot,-g/L*np.sin(fi)]\n\ndef model_linear(ic,t,L):\n fi, fidot = ic\n return [fidot,-g/L*fi]\n\ndef build_model(y0,ypika0,L):\n ic=[y0,ypika0]\n t=np.linspace(0,5,num=500)\n fi=odeint(model_nonlinear,ic,t,args=(L,))\n ys=fi[:,0]\n\n fi_linear=odeint(model_linear,ic,t,args=(L,))\n ys_linear=fi_linear[:,0]\n \n global nonlinear, linear\n\n ax.lines.remove(nonlinear)\n ax.lines.remove(linear)\n \n nonlinear, = ax.plot(t,ys,label='original',color='C0', linewidth=5)\n linear, = ax.plot(t,ys_linear,label='linearizacija',color='C3', linewidth=2)\n \n ax.legend()\n \n ax.relim()\n ax.autoscale_view()\n\nL_slider=widgets.FloatSlider(value=0.3, min=.01, max=2., step=.01,\n description='$L$ [m]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',)\n\nypika0_slider=widgets.FloatSlider(value=1, min=-3, max=3, step=0.1,\n description='$\\dot \\\\theta_0$ [rad/s]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',) \n\ny0_slider=widgets.FloatSlider(value=1, min=-3, max=3, step=0.1,\n description='$\\\\theta_0$ [rad]:',disabled=False,continuous_update=False,\n orientation='horizontal',readout=True,readout_format='.2f',) \n\ninput_data=widgets.interactive_output(build_model, {'y0':y0_slider,'ypika0':ypika0_slider,'L':L_slider})\n\ndisplay(L_slider,y0_slider,ypika0_slider,input_data)\n```\n\n\n \n\n\n\n\n\n\n\n FloatSlider(value=0.3, continuous_update=False, description='$L$ [m]:', max=2.0, min=0.01, step=0.01)\n\n\n\n FloatSlider(value=1.0, continuous_update=False, description='$\\\\theta_0$ [rad]:', max=3.0, min=-3.0)\n\n\n\n FloatSlider(value=1.0, continuous_update=False, description='$\\\\dot \\\\theta_0$ [rad/s]:', max=3.0, min=-3.0)\n\n\n\n Output()\n\n", "meta": {"hexsha": "10f9e2a6c7a4a869d70ae620c26a9c1d4d2b5612", "size": 119128, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_hr/examples/02/TD-06-Linearizacija_njihalo.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-06-Linearizacija_njihalo-checkpoint.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_hr/examples/02/.ipynb_checkpoints/TD-06-Linearizacija_njihalo-checkpoint.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 112.8106060606, "max_line_length": 75963, "alphanum_fraction": 0.7892686858, "converted": true, "num_tokens": 1356, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.21733752104706247, "lm_q1q2_score": 0.10442604480290174}}
{"text": "\n\n## Data-driven Design and Analyses of Structures and Materials (3dasm)\n\n## Lecture 6\n\n### Miguel A. Bessa | M.A.Bessa@tudelft.nl | Associate Professor\n\n**What:** A lecture of the \"3dasm\" course\n\n**Where:** This notebook comes from this [repository](https://github.com/bessagroup/3dasm_course)\n\n**Reference for entire course:** Murphy, Kevin P. *Probabilistic machine learning: an introduction*. MIT press, 2022. Available online [here](https://probml.github.io/pml-book/book1.html)\n\n**How:** We try to follow Murphy's book closely, but the sequence of Chapters and Sections is different. The intention is to use notebooks as an introduction to the topic and Murphy's book as a resource.\n* If working offline: Go through this notebook and read the book.\n* If attending class in person: listen to me (!) but also go through the notebook in your laptop at the same time. Read the book.\n* If attending lectures remotely: listen to me (!) via Zoom and (ideally) use two screens where you have the notebook open in 1 screen and you see the lectures on the other. Read the book.\n\n**Optional reference (the \"bible\" by the \"bishop\"... pun intended 😆) :** Bishop, Christopher M. *Pattern recognition and machine learning*. Springer Verlag, 2006.\n\n**References/resources to create this notebook:**\n* [Car figure](https://korkortonline.se/en/theory/reaction-braking-stopping/)\n\nApologies in advance if I missed some reference used in this notebook. Please contact me if that is the case, and I will gladly include it here.\n\n## **OPTION 1**. Run this notebook **locally in your computer**:\n1. Confirm that you have the 3dasm conda environment (see Lecture 1).\n\n2. Go to the 3dasm_course folder in your computer and pull the last updates of the [repository](https://github.com/bessagroup/3dasm_course):\n```\ngit pull\n```\n3. Open command window and load jupyter notebook (it will open in your internet browser):\n```\nconda activate 3dasm\njupyter notebook\n```\n4. Open notebook of this Lecture.\n\n## **OPTION 2**. Use **Google's Colab** (no installation required, but times out if idle):\n\n1. go to https://colab.research.google.com\n2. login\n3. File > Open notebook\n4. click on Github (no need to login or authorize anything)\n5. paste the git link: https://github.com/bessagroup/3dasm_course\n6. click search and then click on the notebook for this Lecture.\n\n\n```python\n# Basic plotting tools needed in Python.\n\nimport matplotlib.pyplot as plt # import plotting tools to create figures\nimport numpy as np # import numpy to handle a lot of things!\nfrom IPython.display import display, Math # to print with Latex math\n\n%config InlineBackend.figure_format = \"retina\" # render higher resolution images in the notebook\nplt.style.use(\"seaborn\") # style for plotting that comes from seaborn\nplt.rcParams[\"figure.figsize\"] = (8,4) # rescale figure size appropriately for slides\n```\n\n## Outline for today\n\n* Continuation of previous lecture: Bayesian inference for one hidden rv\n - Prior\n - Likelihood\n - Marginal likelihood\n - Posterior\n - Gaussian pdf's product\n\n**Reading material**: This notebook + Chapter 3\n\n## Recap of Lecture 5: car stopping distance with known $x$ and $p(z_2)$\n\nWe focused on the car stopping distance problem with two rv's under the following conditions:\n* We kept $x=75$ m/s.\n* The \"true\" distribution of one of the rv's was known: $p(z_2)=\\mathcal{N}(\\mu_{z_2}=0.1,\\sigma_{z_2}^2=0.01^2)$\n* But the distribution of the other rv ($z \\equiv z_1$) is not known: $p(z)=?$\n\nUnder these conditions, recall the \"true\" model by observing the following plot, including some data observations.\n\n\n```python\n# This cell is hidden during presentation. It's just to define a function to plot the governing model of\n# the car stopping distance problem. Defining a function that creates a plot allows to repeatedly run\n# this function on cells used in this notebook.\ndef car_fig_2rvs(ax):\n x = np.linspace(3, 83, 1000)\n mu_z1 = 1.5; sigma_z1 = 0.5; # parameters of the \"true\" p(z_1)\n mu_z2 = 0.1; sigma_z2 = 0.01; # parameters of the \"true\" p(z_2)\n mu_y = mu_z1*x + mu_z2*x**2 # From Homework of Lecture 4\n sigma_y = np.sqrt( (x*sigma_z1)**2 + (x**2*sigma_z2)**2 ) # From Homework of Lecture 4\n ax.set_xlabel(\"x (m/s)\", fontsize=20) # create x-axis label with font size 20\n ax.set_ylabel(\"y (m)\", fontsize=20) # create y-axis label with font size 20\n ax.set_title(\"Car stopping distance problem with two rv's\", fontsize=20); # create title with font size 20\n ax.plot(x, mu_y, 'k:', label=\"Governing model $\\mu_y$\")\n ax.fill_between(x, mu_y - 1.9600 * sigma_y,\n mu_y + 1.9600 * sigma_y,\n color='k', alpha=0.2,\n label='95% confidence interval ($\\mu_y \\pm 1.96\\sigma_y$)') # plot 95% credence interval\n ax.legend(fontsize=15)\n```\n\n\n```python\n# This cell is also hidden during presentation.\nfrom scipy.stats import norm # import the normal dist, as we learned before!\ndef samples_y_with_2rvs(N_samples,x): # observations/measurements/samples for car stop. dist. prob. with 2 rv's\n mu_z1 = 1.5; sigma_z1 = 0.5;\n mu_z2 = 0.1; sigma_z2 = 0.01;\n samples_z1 = norm.rvs(mu_z1, sigma_z1, size=N_samples) # randomly draw samples from the normal dist.\n samples_z2 = norm.rvs(mu_z2, sigma_z2, size=N_samples) # randomly draw samples from the normal dist.\n samples_y = samples_z1*x + samples_z2*x**2 # compute the stopping distance for samples of z_1 and z_2\n return samples_y # return samples of y\n```\n\n\n```python\n# vvvvvvvvvvv this is just a trick so that we can run this cell multiple times vvvvvvvvvvv\nfig_car_new, ax_car_new = plt.subplots(1,2); plt.close() # create figure and close it\nif fig_car_new.get_axes():\n del ax_car_new; del fig_car_new # delete figure and axes if they exist\n fig_car_new, ax_car_new = plt.subplots(1,2) # create them again\n# ^^^^^^^^^^^ end of the trick ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nN_samples = 3 # CHANGE THIS NUMBER AND RE-RUN THE CELL\nx = 75; empirical_y = samples_y_with_2rvs(N_samples, x); # Empirical measurements of N_samples at x=75\nempirical_mu_y = np.mean(empirical_y); empirical_sigma_y = np.std(empirical_y); # empirical mean and std\ncar_fig_2rvs(ax_car_new[0]) # a function I created to include the background plot of the governing model\nfor i in range(2): # create two plots (one is zooming in on the error bar)\n ax_car_new[i].errorbar(x , empirical_mu_y,yerr=1.96*empirical_sigma_y, fmt='m*', markersize=15);\n ax_car_new[i].scatter(x*np.ones_like(empirical_y),empirical_y, s=40,\n facecolors='none', edgecolors='k', linewidths=2.0)\nprint(\"Empirical mean[y] is\",empirical_mu_y, \"(real mean[y]=675)\")\nprint(\"Empirical std[y] is\",empirical_sigma_y,\"(real std[y]=67.6)\")\nfig_car_new.set_size_inches(25, 5) # scale figure to be wider (since there are 2 subplots)\n```\n\n## Recap of Lecture 5: Summary of our model\n\n1. The **observation distribution**:\n\n$$\np(y|z) = \\mathcal{N}\\left(y | \\mu_{y|z}=w z+b, \\sigma_{y|z}^2\\right) = \\frac{1}{C_{y|z}} \\exp\\left[ -\\frac{1}{2\\sigma_{y|z}^2}(y-\\mu_{y|z})^2\\right]\n$$\n\nwhere $C_{y|z} = \\sqrt{2\\pi \\sigma_{y|z}^2}$ is the **normalization constant** of the Gaussian pdf, and where $\\mu_{y|z}=w z+b$, with $w$, $b$ and $\\sigma_{y|z}^2$ being constants.\n\n2. and the **prior distribution**: $p(z) = \\frac{1}{C_z}$\n\nwhere $C_z = z_{max}-z_{min}$ is the **normalization constant** of the Uniform pdf, i.e. the value that guarantees that $p(z)$ integrates to one.\n\n### Recap of Lecture 5: Data\n\n* Since we usually don't know the true process, we can only observe/collect data $y=\\mathcal{D}_y$:\n\n\n```python\nprint(\"Example of N=%1i data points for y at x=%1.1f m/s with :\" % (N_samples,x), empirical_y)\n```\n\n Example of N=3 data points for y at x=75.0 m/s with : [641.47373038 733.92797742 637.52728953]\n\n\n## Recap of Lecture 5: Posterior from Bayes' rule applied to data\n\nUse Bayes' rule applied to data to determine the posterior :\n\n$\\require{color}$\n$$\n{\\color{green}p(z|y=\\mathcal{D}_y)} = \\frac{ {\\color{blue}p(y=\\mathcal{D}_y|z)}{\\color{red}p(z)} } {p(y=\\mathcal{D}_y)}\n$$\n\nThat requires calculating the likelihood (here, it results from a product of Gaussian densities):\n\n$$\n{\\color{blue}p(y=\\mathcal{D}_y | z)} = \\frac{1}{|w|^N} \\cdot C \\cdot \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp\\left[ -\\frac{1}{2\\sigma^2}(z-\\mu)^2\\right]\n$$\n\nwhere $\\mu = \\frac{w^2\\sigma^2}{\\sigma_{y|z}^2} \\sum_{i=1}^N \\mu_i$\n\n$\\sigma^2 = \\frac{\\sigma_{y|z}^2}{w^2 N}$, and\n\n$C = \\frac{1}{2\\pi^{(N-1)/2}} \\sqrt{\\frac{\\sigma^2}{\\left( \\frac{\\sigma_{y|z}^2}{w^2}\\right)^N}}\n$\n\nAfter calculating the likelihood, we determined the marginal likelihood:\n\n$$\np(y=\\mathcal{D}_y) = \\frac{C}{|w|^N C_z}\n$$\n\nFrom which we got the posterior :\n\n$$\\require{color}\\begin{align}\n{\\color{green}p(z|y=\\mathcal{D}_y)} &= \\frac{ p(y=\\mathcal{D}_y|z)p(z) } {p(y=\\mathcal{D}_y)} \\\\\n&= \\frac{1}{p(y=\\mathcal{D}_y)} \\cdot \\frac{1}{|w|^N} C \\cdot \\mathcal{N}(z|\\mu,\\sigma^2) \\cdot \\frac{1}{C_z} \\\\\n&= \\mathcal{N}(z|\\mu, \\sigma^2)\n\\end{align}\n$$\n\nwhich is a **normalized** Gaussian pdf in $z$ with mean and variance as shown in the previous cell.\n\n## Determining the Posterior Predictive Distribution (PPD ) from the posterior\n\nHowever, as we mentioned, Bayes' rule is just a way to calculate the posterior:\n\n$$\np(z|y=\\mathcal{D}_y) = \\frac{ p(y=\\mathcal{D}_y|z)p(z) } {p(y=\\mathcal{D}_y)}\n$$\n\nWhat we really want is the Posterior Predictive Distribution (PPD ) . This comes after calculating the posterior given some data $\\mathcal{D}_y$:\n\n$$\\require{color}\n{\\color{orange}p(y|y=\\mathcal{D}_y)} = \\int p(y|z) p(z|y=\\mathcal{D}_y) dz\n$$\n\nwhich is often written in simpler notation: $p(y|\\mathcal{D}_y) = \\int p(y|z) p(z|\\mathcal{D}_y) dz$\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\int \\underbrace{p(y|z)}_{\\text{observation}\\\\ \\text{distribution}} \\overbrace{p(z|y=\\mathcal{D}_y)}^{\\text{posterior}} dz\n$$\n\nConsidering the terms we found before, we get:\n\n$$\\begin{align}\np(y|\\mathcal{D}_y) &= \\int \\underbrace{\\frac{1}{|w|}\\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\} }_{\\text{observation}\\\\ \\text{distribution}} \\overbrace{\\mathcal{N}(z|\\mu, \\sigma^2)}^{\\text{posterior}} dz\n\\end{align}\n$$\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\frac{1}{|w|} \\int {\\color{blue}\\frac{1}{\\sqrt{2\\pi \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}} \\exp\\left\\{ -\\frac{1}{2\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2}\\left[z-\\left(\\frac{y-b}{w}\\right)\\right]^2\\right\\}} \\mathcal{N}(z|\\mu, \\sigma^2) dz\n$$\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\frac{1}{|w|} \\int \\mathcal{N}\\left(z\\left|\\frac{y-b}{w}, \\left(\\frac{\\sigma_{y|z}}{w}\\right)^2\\right.\\right) \\mathcal{N}(z|\\mu, \\sigma^2) dz\n$$\n\nThis is (again!) the product of two Gaussians!\n\nIn Lecture 5 (and the Homework!) you saw (and demonstrated!) that the product of two or more univariate (and multivariate!) Gaussians is...\n\n* Another Gaussian! Although it needs to be scaled by a constant...\n\nSo, we conclude that the PPD is an integral of a Gaussian:\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\frac{1}{|w|} \\int C^* \\mathcal{N}\\left(z|\\mu^*, \\left(\\sigma^*\\right)^2\\right) dz\n$$\n\n\nwhere $\\mu^* = \\left(\\sigma^* \\right)^2 \\left( \\frac{\\mu}{\\sigma^2} + \\frac{(y-b)/w}{\\left(\\frac{\\sigma_{y|z}}{w}\\right)^2} \\right) = \\left(\\sigma^* \\right)^2 \\left( \\frac{\\mu}{\\sigma^2} + \\frac{(y-b)\\cdot w}{\\sigma_{y|z}^2} \\right)$\n\n$\\left( \\sigma^* \\right)^2 = \\frac{1}{\\frac{1}{\\sigma^2}+\\frac{1}{\\left( \\frac{\\sigma_{y|z}}{w}\\right)^2}}= \\frac{1}{\\frac{1}{\\sigma^2}+\\frac{w^2}{\\sigma_{y|z}^2}}$\n\n$C^* = \\frac{1}{\\sqrt{2\\pi \\left( \\sigma^2 + \\frac{\\sigma_{y|z}^2}{w^2} \\right)}}\\exp\\left[ - \\frac{\\left(\\mu - \\frac{y-b}{w}\\right)^2}{2\\left( \\sigma^2+\\frac{\\sigma_{y|z}^2}{w^2}\\right)}\\right]$\n\nThis integral is simple to solve!\n\n$$\\require{color}\n\\begin{align}\n{\\color{orange}p(y|\\mathcal{D}_y)} &= \\frac{1}{|w|} \\int C^* \\mathcal{N}\\left(z|\\mu^*, \\left(\\sigma^*\\right)^2\\right) dz \\\\\n&= \\frac{C^*}{|w|} \\int {\\color{blue}\\mathcal{N}\\left(z|\\mu^*, \\left(\\sigma^*\\right)^2\\right)} dz\n\\end{align}\n$$\n\nWhat's the result of integrating the blue term?\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\frac{C^*}{|w|}\n$$\n\n## Exercise 1\n\nRewrite the PPD to show that it becomes:\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\mathcal{N}\\left(y| b+\\mu w, w^2\\sigma^2+\\sigma_{y|z}^2 \\right)\n$$\n\na normalized univariate Gaussian!\n\n## A long way to show that the PPD is a simple Gaussian...\n\n$$\\require{color}\n{\\color{orange}p(y|\\mathcal{D}_y)} = \\mathcal{N}\\left(y| b+\\mu w, w^2\\sigma^2+\\sigma_{y|z}^2 \\right)\n$$\n\nwhere we recall that each constant is:\n\n$b = 0.1x^2 = 562.5$\n\n$w = x = 75$\n\n$\\sigma_{y|z}^2 = (x^2 \\sigma_{z_2})^2=(75^2\\cdot0.01)^2=56.25^2$\n\n$\\sigma^2 = \\frac{\\sigma_{y|z}^2}{w^2 N} = \\frac{(x^2\\cdot\\sigma_{z_2})^2}{x^2 N} = \\frac{x^2\\cdot\\sigma_{z_2}^2}{N} $\n\n$\\mu = \\frac{w^2 \\sigma^2}{\\sigma_{y|z}^2} \\sum_{i=1}^{N} \\mu_i = \\cdots = \\frac{\\sum_{i=1}^N y_i}{w N}-\\frac{b}{w}$\n\n\n#### Note on algebra to determine $\\mu$ parameter:\n\n$$\n\\begin{align}\n\\mu &= \\frac{w^2 \\sigma^2}{\\sigma_{y|z}^2} \\sum_{i=1}^{N} \\mu_i \\\\\n&= \\frac{\\sum_{i=1}^{N} \\mu_i}{N} = \\frac{1}{N} \\sum_{i=1}^{N} \\left(\\frac{y_i-b}{w}\\right) \\\\\n&= \\frac{1}{w N} \\sum_{i=1}^N\\left( y_i-b\\right) \\\\\n&= \\frac{1}{w N} \\left( \\sum_{i=1}^N y_i-N b\\right) \\\\\n& = \\frac{\\sum_{i=1}^N y_i}{w N}-\\frac{b}{w}\n\\end{align}\n$$\n\n## A long way to show that the PPD is a simple Gaussian...\n\n$$\\require{color}\n\\begin{align}\n{\\color{orange}p(y|\\mathcal{D}_y)} &= \\mathcal{N}\\left(y| b+\\mu w, w^2\\sigma^2+\\sigma_{y|z}^2 \\right) \\\\\n&= \\mathcal{N}\\left(y \\left| \\left(\\sum_{i=1}^N \\frac{y_i}{N}\\right), \\sigma_{y|z}^2 \\left(\\frac{1}{N} + 1 \\right) \\right. \\right)\n\\end{align}\n$$\n\nwhere $y_i$ are each of the $N$ data points of the observed data $\\mathcal{D}_y$, and $\\sigma_{y|z}^2 = (x^2 \\sigma_{z_2})^2=(75^2\\cdot0.01)^2=56.25^2$ is the variance arising from the contribution of $z_2$ on $y$.\n\n* **Very Important Questions (VIQs)**: What does this result tell us? Did you expect this predicted distribution for $y$?\n\n\n```python\nfig_car_PPD, ax_car_PPD = plt.subplots(1,2); plt.close() # create figure and close it\nif fig_car_new.get_axes():\n del ax_car_PPD; del fig_car_PPD; fig_car_PPD, ax_car_PPD = plt.subplots(1,2) # delete fig & axes & create them\nN_samples = 30000 # CHANGE THIS NUMBER AND RE-RUN THE CELL\nx = 75; empirical_y = samples_y_with_2rvs(N_samples, x); # Empirical measurements of N_samples at x=75\nempirical_mu_y = np.mean(empirical_y); empirical_sigma_y = np.std(empirical_y); # empirical mean and std\n# Calculate PPD mean and standard deviation:\nPPD_mu_y = np.mean(empirical_y); sigma_z2 = 0.01; PPD_sigma_y = np.sqrt( (x**2*sigma_z2)**2*(1/N_samples + 1) )\ncar_fig_2rvs(ax_car_PPD[0]) # a function I created to include the background plot of the governing model\nfor i in range(2): # create two plots (one is zooming in on the error bar)\n ax_car_PPD[i].errorbar(x , empirical_mu_y,yerr=1.96*empirical_sigma_y, fmt='m*', markersize=15, elinewidth=6);\n ax_car_PPD[i].errorbar(x , PPD_mu_y,yerr=1.96*PPD_sigma_y, color='#F39C12', fmt='*', markersize=5, elinewidth=3);\n ax_car_PPD[i].scatter(x*np.ones_like(empirical_y),empirical_y, s=100,facecolors='none', edgecolors='k', linewidths=2.0)\nprint(\"PPD & empirical mean[y] are the same:\",empirical_mu_y, \"(real mean[y]=675)\")\nprint(\"PPD std[y] is\",PPD_sigma_y, \"& empirical std[y] is\",empirical_sigma_y,\"(real std[y]=67.6)\")\nfig_car_PPD.set_size_inches(25, 5) # scale figure to be wider (since there are 2 subplots)\n```\n\n### Reflection on what we are observing\n\n1. Generally speaking, our PPD is quite reasonable!\n * For few data points it is more reasonable than just calculating the standard deviation directly from the data.\n\n2. However, as the number of data points increases it starts getting \"overconfident\" (see PPD as $N\\rightarrow \\infty$ or play with the figure above by increasing $N$).\n * This results from our choice of prior... Our belief was incorrect.\n * The hidden rv $z$ is actually a Gaussian distribution, instead of a noninformative Uniform distribution\n\nPlease keep this in your head:\n* (Bayesian) ML is not magic. Every modeling choice you make affects the predictions you get.\n* Of course, there are ways of getting \"closer\" to the truth! We'll take some steps in that direction in the remainder of the course. \n\n# HOMEWORK \n\nConsider the same problem, but now starting from a different model:\n\n1. Same **observation distribution** as before:\n\n$$\np(y|z) = \\mathcal{N}\\left(y | \\mu_{y|z}=w z+b, \\sigma_{y|z}^2\\right) = \\frac{1}{C_{y|z}} \\exp\\left[ -\\frac{1}{2\\sigma_{y|z}^2}(y-\\mu_{y|z})^2\\right]\n$$\n\n2. but now assuming a different **prior distribution** : $p(z) = \\mathcal{N}\\left(z| \\overset{\\scriptscriptstyle <}{\\mu}_z=3, \\overset{\\scriptscriptstyle <}{\\sigma}_z^2=2^2\n\\right)$\n\nIn my notation, the superscript $\\overset{\\scriptscriptstyle <}{(\\cdot)}$ indicates a parameter of the prior distribution.\n\n### Notes about the prior distribution\n\n* We would have to be very lucky if our \"belief\" coincided with the \"true\" distribution of $z$.\n * Usually, we have beliefs but they are not really true (not talking about religion 😆).\n - Our hope is that our beliefs are at least reasonable!\n\n* When defining a prior we are making a decision about two things:\n 1. The distribution.\n * For example, in this exercise we are assuming that the prior is Gaussian (before we assumed a noninformative Uniform prior). In this case we hit the jackpot! But remember that we are cheating here... That's why we know the actual distribution of $z$ is a Gaussian!\n 2. The parameters of the distribution.\n * For example, in this exercise we are assuming values that are not the true ones! This is normal! As I said, usually we don't know the truth about the \"hidden\" variable. Most times we don't even know how many hidden variables we have...\n\n### See you next class\n\nHave fun!\n", "meta": {"hexsha": "1dd4f321a74a6fecd3730d4f47bab03c54690eb2", "size": 332767, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture6/3dasm_Lecture6.ipynb", "max_stars_repo_name": "shushu-qin/3dasm_course", "max_stars_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-02-07T18:45:48.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-23T21:45:27.000Z", "max_issues_repo_path": "Lectures/Lecture6/3dasm_Lecture6.ipynb", "max_issues_repo_name": "shushu-qin/3dasm_course", "max_issues_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture6/3dasm_Lecture6.ipynb", "max_forks_repo_name": "shushu-qin/3dasm_course", "max_forks_repo_head_hexsha": "a53ce9f8d7c692a9b1356946ec11e60b35b7bbcd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2022-02-07T18:45:49.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-25T19:30:17.000Z", "avg_line_length": 383.3721198157, "max_line_length": 152028, "alphanum_fraction": 0.9283703011, "converted": true, "num_tokens": 6108, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.33458944125318596, "lm_q2_score": 0.31069437683198775, "lm_q1q2_score": 0.10395505794472158}}
{"text": "```python\nfrom resources.workspace import *\n```\n\n$\n% START OF MACRO DEF\n% DO NOT EDIT IN INDIVIDUAL NOTEBOOKS, BUT IN macros.py\n%\n\\newcommand{\\Reals}{\\mathbb{R}}\n\\newcommand{\\Expect}[0]{\\mathbb{E}}\n\\newcommand{\\NormDist}{\\mathcal{N}}\n%\n\\newcommand{\\DynMod}[0]{\\mathscr{M}}\n\\newcommand{\\ObsMod}[0]{\\mathscr{H}}\n%\n\\newcommand{\\mat}[1]{{\\mathbf{{#1}}}} \n%\\newcommand{\\mat}[1]{{\\pmb{\\mathsf{#1}}}}\n\\newcommand{\\bvec}[1]{{\\mathbf{#1}}} \n%\n\\newcommand{\\trsign}{{\\mathsf{T}}} \n\\newcommand{\\tr}{^{\\trsign}} \n\\newcommand{\\tn}[1]{#1} \n\\newcommand{\\ceq}[0]{\\mathrel{≔}}\n%\n\\newcommand{\\I}[0]{\\mat{I}} \n\\newcommand{\\K}[0]{\\mat{K}}\n\\newcommand{\\bP}[0]{\\mat{P}}\n\\newcommand{\\bH}[0]{\\mat{H}}\n\\newcommand{\\bF}[0]{\\mat{F}}\n\\newcommand{\\R}[0]{\\mat{R}}\n\\newcommand{\\Q}[0]{\\mat{Q}}\n\\newcommand{\\B}[0]{\\mat{B}}\n\\newcommand{\\C}[0]{\\mat{C}}\n\\newcommand{\\Ri}[0]{\\R^{-1}}\n\\newcommand{\\Bi}[0]{\\B^{-1}}\n\\newcommand{\\X}[0]{\\mat{X}}\n\\newcommand{\\A}[0]{\\mat{A}}\n\\newcommand{\\Y}[0]{\\mat{Y}}\n\\newcommand{\\E}[0]{\\mat{E}}\n\\newcommand{\\U}[0]{\\mat{U}}\n\\newcommand{\\V}[0]{\\mat{V}}\n%\n\\newcommand{\\x}[0]{\\bvec{x}}\n\\newcommand{\\y}[0]{\\bvec{y}}\n\\newcommand{\\z}[0]{\\bvec{z}}\n\\newcommand{\\q}[0]{\\bvec{q}}\n\\newcommand{\\br}[0]{\\bvec{r}}\n\\newcommand{\\bb}[0]{\\bvec{b}}\n%\n\\newcommand{\\bx}[0]{\\bvec{\\bar{x}}}\n\\newcommand{\\by}[0]{\\bvec{\\bar{y}}}\n\\newcommand{\\barB}[0]{\\mat{\\bar{B}}}\n\\newcommand{\\barP}[0]{\\mat{\\bar{P}}}\n\\newcommand{\\barC}[0]{\\mat{\\bar{C}}}\n\\newcommand{\\barK}[0]{\\mat{\\bar{K}}}\n%\n\\newcommand{\\D}[0]{\\mat{D}}\n\\newcommand{\\Dobs}[0]{\\mat{D}_{\\text{obs}}}\n\\newcommand{\\Dmod}[0]{\\mat{D}_{\\text{obs}}}\n%\n\\newcommand{\\ones}[0]{\\bvec{1}} \n\\newcommand{\\AN}[0]{\\big( \\I_N - \\ones \\ones\\tr / N \\big)}\n%\n% END OF MACRO DEF\n$\nIn this tutorial we shall derive:\n\n# the Kalman filter for multivariate systems. \n\nThe [forecast step](T3%20-%20Univariate%20Kalman%20filtering.ipynb#Exc-3.7:-The-forecast-step:)\nremains essentially unchanged.\nThe only difference is that $\\DynMod$ is now a matrix, as well as the use of the transpose ${}^T$ in the covariance equation:\n$\\begin{align}\n\\bb_k\n&= \\DynMod_{k-1} \\hat{\\x}_{k-1} \\, , \\tag{1a} \\\\\\\n\\B_k\n&= \\DynMod_{k-1} \\bP_{k-1} \\DynMod_{k-1}^T + \\Q_{k-1} \\, . \\tag{1b}\n\\end{align}$\n\nHowever, the analysis step [[Exc 2.18](T2%20-%20Bayesian%20inference.ipynb#Exc--2.18-'Gaussian-Bayes':)] gets a little more complicated...\n\n#### Exc 2 (The likelihood):\n\nThe analysis step is only concerned with a single time (index). We therefore drop the $k$ subscript in the following.\n \nWe have now derived (one form of) the Kalman filter. In the multivariate case,\nwe know how to:\n\n Propagate our estimate of $\\x$ to the next time step using eqns (1a) and (1b). \n Update our estimate of $\\x$ by assimilating the latest observation $\\y$, using eqns (5) and (6). \n \n \n\n## Live Lecture - Deriving Bayes' Theorem, Calculating Bayesian Confidence\n\nNotice that $P(A|B)$ appears in the above laws - in Bayesian terms, this is the belief in $A$ updated for the evidence $B$. So all we need to do is solve for this term to derive Bayes' theorem. Let's do it together!\n\n\n```\n# Activity 2 - Use SciPy to calculate Bayesian confidence intervals\n# https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.bayes_mvs.html#scipy.stats.bayes_mvs\n```\n\n\n```\nfrom scipy import stats\nimport numpy as np\n\nnp.random.seed(seed=42)\n\ncoinflips = np.random.binomial(n=1, p=.5, size=100)\nprint(coinflips)\n```\n\n [0 1 1 1 0 0 0 1 1 1 0 1 1 0 0 0 0 1 0 0 1 0 0 0 0 1 0 1 1 0 1 0 0 1 1 1 0\n 0 1 0 0 0 0 1 0 1 0 1 1 0 1 1 1 1 1 1 0 0 0 0 0 0 1 0 0 1 0 1 0 1 1 0 0 1\n 1 1 1 0 0 0 1 1 0 0 0 0 1 1 1 0 0 1 1 1 1 0 1 0 0 0]\n\n\n\n```\ndef confidence_interval(data, confidence=.95):\n n = len(data)\n mean = sum(data)/n\n data = np.array(data)\n stderr = stats.sem(data)\n interval = stderr * stats.t.ppf((1 + confidence) / 2.0, n-1)\n return (mean , mean-interval, mean+interval)\n```\n\n\n```\nconfidence_interval(coinflips, confidence=.95)\n```\n\n\n\n\n (0.47, 0.3704689875017368, 0.5695310124982632)\n\n\n\n\n```\nmean_CI, _, _ = stats.bayes_mvs(coinflips, alpha=.95)\n \nmean_CI\n```\n\n\n\n\n Mean(statistic=0.47, minmax=(0.37046898750173674, 0.5695310124982632))\n\n\n\n\n```\n??stats.bayes_mvs\n```\n\n\n```\ncoinflips_mean_dist, _, _ = stats.mvsdist(coinflips)\ncoinflips_mean_dist\n```\n\n\n\n\n \n\n\n\n\n```\ncoinflips_mean_dist.rvs(1000)\n```\n\n\n\n\n array([0.47447628, 0.51541425, 0.54722018, 0.4589882 , 0.51501386,\n 0.53819192, 0.43382292, 0.53546659, 0.47026173, 0.44967562,\n 0.4621107 , 0.42691904, 0.37324325, 0.47531437, 0.46052277,\n 0.48711257, 0.52456771, 0.43332181, 0.49545882, 0.44671454,\n 0.47520117, 0.47047251, 0.41828918, 0.50159477, 0.42965501,\n 0.45273383, 0.48045849, 0.45342529, 0.48238344, 0.53966291,\n 0.48230241, 0.48073422, 0.48553525, 0.47962228, 0.41274185,\n 0.42892633, 0.5170948 , 0.42678096, 0.42249309, 0.51499109,\n 0.47059199, 0.39903942, 0.41790336, 0.46406817, 0.42232382,\n 0.42163269, 0.47848227, 0.48232842, 0.4731858 , 0.51077244,\n 0.3957508 , 0.48504646, 0.49014295, 0.53252732, 0.45495376,\n 0.47883978, 0.60393033, 0.4492549 , 0.44797902, 0.54782121,\n 0.43380002, 0.5760073 , 0.36941266, 0.44467418, 0.4939245 ,\n 0.45278835, 0.55635162, 0.48695459, 0.39080983, 0.45948606,\n 0.2941779 , 0.35950718, 0.44805696, 0.4725126 , 0.42218381,\n 0.45985418, 0.47545393, 0.44317753, 0.46267013, 0.4458753 ,\n 0.44204707, 0.51334913, 0.50914181, 0.49923748, 0.46895674,\n 0.43892798, 0.45984946, 0.44984632, 0.53560791, 0.45865723,\n 0.48646824, 0.55937503, 0.41464303, 0.50701457, 0.46934196,\n 0.37681534, 0.42748113, 0.49812825, 0.48278895, 0.4964763 ,\n 0.3891381 , 0.43956744, 0.48413544, 0.45477873, 0.48725027,\n 0.49464113, 0.50575373, 0.47327346, 0.47520013, 0.58130199,\n 0.5845843 , 0.46478398, 0.4258629 , 0.52948199, 0.48513203,\n 0.49687534, 0.41137211, 0.46621924, 0.3914774 , 0.48360179,\n 0.38619449, 0.48277886, 0.47026304, 0.45226139, 0.47583911,\n 0.51800201, 0.48765985, 0.47519588, 0.56197092, 0.41764152,\n 0.49955199, 0.4476301 , 0.53072591, 0.51503605, 0.54521753,\n 0.51825987, 0.38392617, 0.46969675, 0.40735953, 0.41644585,\n 0.46704857, 0.44673322, 0.44172829, 0.39682358, 0.56863866,\n 0.49382431, 0.46425614, 0.43441607, 0.45352793, 0.43280667,\n 0.49838641, 0.42134069, 0.39030482, 0.46056071, 0.43477593,\n 0.48030697, 0.46963763, 0.58135074, 0.41707759, 0.54735952,\n 0.40234266, 0.44587394, 0.43824819, 0.34994202, 0.45715098,\n 0.48171551, 0.49707708, 0.56201387, 0.43796178, 0.48736057,\n 0.48396275, 0.4137432 , 0.43730294, 0.44127354, 0.49414193,\n 0.37391405, 0.48951459, 0.49203495, 0.48750347, 0.4535989 ,\n 0.4826649 , 0.45727017, 0.35957717, 0.52627891, 0.48671508,\n 0.5146115 , 0.40126273, 0.49351532, 0.47899387, 0.41170621,\n 0.47372827, 0.45349404, 0.45541059, 0.44761163, 0.50985422,\n 0.38946749, 0.38924167, 0.477608 , 0.47523283, 0.48057958,\n 0.55631265, 0.47918939, 0.41974198, 0.59314567, 0.46179892,\n 0.52111564, 0.39858206, 0.39293582, 0.45738699, 0.51094648,\n 0.55605523, 0.42063349, 0.4553239 , 0.47003479, 0.47070228,\n 0.46428309, 0.46828548, 0.55559626, 0.54327956, 0.48485723,\n 0.39503943, 0.45169487, 0.51312502, 0.43261878, 0.44449548,\n 0.45205734, 0.50467902, 0.55919291, 0.50052268, 0.39552378,\n 0.44554284, 0.54545754, 0.41285254, 0.37820216, 0.4433361 ,\n 0.51902109, 0.45162443, 0.57347586, 0.47871392, 0.40561444,\n 0.48058706, 0.56598937, 0.48203328, 0.42126387, 0.368201 ,\n 0.45272922, 0.43585457, 0.54199909, 0.42996167, 0.474737 ,\n 0.44127776, 0.39061556, 0.46844006, 0.38929335, 0.49974341,\n 0.38804905, 0.46641358, 0.52312717, 0.49613505, 0.44815583,\n 0.49130684, 0.51080517, 0.41943377, 0.52715474, 0.51901749,\n 0.40173031, 0.48157307, 0.45698766, 0.54181905, 0.5128087 ,\n 0.4738456 , 0.53469041, 0.58876563, 0.37350851, 0.44841936,\n 0.41531469, 0.46828303, 0.41863695, 0.52030773, 0.59197971,\n 0.47809192, 0.39139708, 0.43735205, 0.44473506, 0.54450722,\n 0.4877697 , 0.48142576, 0.4282081 , 0.43828492, 0.49536959,\n 0.46056192, 0.51769419, 0.44435832, 0.2833451 , 0.44709257,\n 0.39013597, 0.49752388, 0.48941684, 0.51950258, 0.43841402,\n 0.461676 , 0.4364845 , 0.47132422, 0.5159512 , 0.40504394,\n 0.54411978, 0.48126155, 0.53768622, 0.44783793, 0.45195711,\n 0.53732665, 0.48919172, 0.54916543, 0.38184422, 0.3839936 ,\n 0.50047602, 0.4827814 , 0.45782355, 0.57051467, 0.51586565,\n 0.41297865, 0.49549503, 0.4867028 , 0.49218095, 0.47941133,\n 0.4179382 , 0.43990307, 0.43267506, 0.51435874, 0.45603811,\n 0.44264597, 0.5258102 , 0.42116497, 0.59109176, 0.45889992,\n 0.42601209, 0.41855971, 0.51763858, 0.53603004, 0.55891986,\n 0.51308977, 0.47539497, 0.57980186, 0.45166958, 0.4360487 ,\n 0.4160565 , 0.46894016, 0.42544503, 0.4718965 , 0.44509759,\n 0.4553363 , 0.51417409, 0.40125374, 0.40141203, 0.52444062,\n 0.38433692, 0.53755945, 0.49124436, 0.44092107, 0.48664193,\n 0.49809931, 0.35939896, 0.45019818, 0.51452836, 0.44702996,\n 0.39014382, 0.4742493 , 0.45802077, 0.54117637, 0.50917065,\n 0.48864846, 0.45513837, 0.46638664, 0.46289285, 0.474597 ,\n 0.47679289, 0.53272938, 0.4273865 , 0.53018322, 0.48459184,\n 0.46054965, 0.46864369, 0.47940797, 0.47963348, 0.50495819,\n 0.43197032, 0.46684607, 0.48552696, 0.45851019, 0.52062144,\n 0.45638092, 0.4765386 , 0.40863058, 0.42996211, 0.43454883,\n 0.47898572, 0.44026601, 0.47275271, 0.39097285, 0.58139265,\n 0.49820118, 0.45762952, 0.43127976, 0.42291755, 0.47822454,\n 0.54221029, 0.41974753, 0.42307496, 0.4404098 , 0.54071199,\n 0.47650072, 0.52908201, 0.43292955, 0.52911544, 0.40416927,\n 0.51208142, 0.43676583, 0.59252479, 0.50098008, 0.52513111,\n 0.43895871, 0.48582562, 0.43385598, 0.51551279, 0.49560729,\n 0.4116628 , 0.47181415, 0.44020566, 0.48571059, 0.40538225,\n 0.55172833, 0.47509918, 0.49899901, 0.42421471, 0.43601874,\n 0.44018693, 0.5304447 , 0.43289087, 0.476795 , 0.41250698,\n 0.38083118, 0.58788278, 0.46971184, 0.45125409, 0.47414778,\n 0.4974292 , 0.46069729, 0.42235771, 0.52285515, 0.59676334,\n 0.4705739 , 0.44988487, 0.47274685, 0.37493384, 0.42223226,\n 0.49987446, 0.46030573, 0.44077887, 0.43844871, 0.47083241,\n 0.49024836, 0.49153355, 0.40008594, 0.53218928, 0.43465945,\n 0.51603003, 0.39652748, 0.41985494, 0.53091204, 0.40977991,\n 0.46225922, 0.41771646, 0.43867606, 0.38712168, 0.58344414,\n 0.48316133, 0.47170139, 0.47396495, 0.45185247, 0.43308114,\n 0.53336288, 0.44655484, 0.52674401, 0.49790806, 0.45346429,\n 0.49966867, 0.43964157, 0.5347767 , 0.49514565, 0.49845113,\n 0.40907362, 0.4988595 , 0.45864058, 0.40669431, 0.46175527,\n 0.5317036 , 0.50075453, 0.48638633, 0.49108861, 0.471713 ,\n 0.48383151, 0.37494445, 0.50690883, 0.43971337, 0.45880774,\n 0.48454783, 0.41166892, 0.48265585, 0.43225349, 0.39086731,\n 0.50734673, 0.42186418, 0.48059622, 0.55935268, 0.39964071,\n 0.47968735, 0.44197047, 0.5523577 , 0.5194387 , 0.46967629,\n 0.46114995, 0.51547562, 0.41173477, 0.42714514, 0.54287129,\n 0.47917532, 0.52899054, 0.52902622, 0.55529675, 0.39260093,\n 0.47808929, 0.5227214 , 0.49686402, 0.41385472, 0.46877338,\n 0.51290447, 0.42081246, 0.48763814, 0.46488503, 0.48815416,\n 0.51874676, 0.44349542, 0.35529184, 0.48235864, 0.38829235,\n 0.41629837, 0.49353573, 0.42837918, 0.43078333, 0.51282674,\n 0.49055841, 0.48687382, 0.4024712 , 0.45031963, 0.49709223,\n 0.54003902, 0.43554303, 0.53183842, 0.486558 , 0.45249906,\n 0.51469574, 0.42098649, 0.45018556, 0.37915825, 0.55746338,\n 0.50905594, 0.49594724, 0.51327984, 0.4526535 , 0.48421933,\n 0.58224419, 0.47947599, 0.46611747, 0.52237733, 0.46120613,\n 0.47167891, 0.49850872, 0.4311296 , 0.47774032, 0.45230789,\n 0.35840294, 0.44659314, 0.51071187, 0.44069454, 0.55320876,\n 0.39988476, 0.49035529, 0.48985295, 0.44694677, 0.45049715,\n 0.51842605, 0.37342115, 0.49553783, 0.504753 , 0.49098663,\n 0.4218805 , 0.52620235, 0.4827884 , 0.44288146, 0.45916104,\n 0.49631062, 0.51646158, 0.48630302, 0.37307539, 0.41265663,\n 0.49024564, 0.46467903, 0.47432696, 0.47325263, 0.48613461,\n 0.51737977, 0.49745443, 0.43226223, 0.51386209, 0.54409309,\n 0.42166633, 0.45683158, 0.49113578, 0.47195372, 0.46461796,\n 0.43912749, 0.4570565 , 0.3981925 , 0.45969044, 0.45356353,\n 0.49012313, 0.46231133, 0.42623662, 0.52407443, 0.4489394 ,\n 0.36793671, 0.50496954, 0.4459393 , 0.47762308, 0.45557782,\n 0.42430219, 0.46342973, 0.49607806, 0.42021132, 0.47986594,\n 0.43995321, 0.47310004, 0.46830237, 0.6095986 , 0.47867353,\n 0.50938602, 0.44119682, 0.41853036, 0.54135276, 0.3737122 ,\n 0.54427806, 0.4251556 , 0.41348475, 0.41993261, 0.52989098,\n 0.462017 , 0.51346035, 0.56842082, 0.44612654, 0.4650062 ,\n 0.46543262, 0.37686614, 0.50593036, 0.38350366, 0.41051578,\n 0.5477685 , 0.37572632, 0.40238182, 0.37546585, 0.46061846,\n 0.34000573, 0.48379551, 0.4102443 , 0.46841925, 0.48235662,\n 0.4521498 , 0.50212742, 0.46316433, 0.52688369, 0.39250788,\n 0.44273506, 0.60936845, 0.46729244, 0.48883352, 0.45995963,\n 0.52954227, 0.50744425, 0.5702215 , 0.4322026 , 0.52990493,\n 0.51626873, 0.4946539 , 0.5082119 , 0.49850001, 0.46857659,\n 0.37680806, 0.42922449, 0.4714559 , 0.47006439, 0.46103295,\n 0.38448095, 0.51598495, 0.51233212, 0.39171157, 0.47295778,\n 0.42799097, 0.31999544, 0.43777493, 0.51361593, 0.48083238,\n 0.49048985, 0.37754081, 0.44390605, 0.43851769, 0.45367766,\n 0.43004286, 0.39810176, 0.52425887, 0.5132496 , 0.46711766,\n 0.5371266 , 0.49789306, 0.47440018, 0.48044375, 0.46275003,\n 0.32760769, 0.43969128, 0.53361144, 0.50404316, 0.45660878,\n 0.39614646, 0.5306167 , 0.41652062, 0.47978152, 0.44229313,\n 0.38296985, 0.4576275 , 0.51705712, 0.46901214, 0.57001682,\n 0.50423767, 0.45819868, 0.47460827, 0.52497238, 0.47857488,\n 0.34748446, 0.46412874, 0.43491473, 0.47103418, 0.45914633,\n 0.4506799 , 0.48795458, 0.49316724, 0.41450339, 0.45860263,\n 0.48590433, 0.43353272, 0.47182887, 0.57180098, 0.51429135,\n 0.36982541, 0.45893858, 0.44927164, 0.47235794, 0.58265714,\n 0.478167 , 0.49140614, 0.46531855, 0.50984351, 0.4827639 ,\n 0.45424265, 0.5015955 , 0.40968418, 0.49247972, 0.44791535,\n 0.43087735, 0.5079453 , 0.39380662, 0.38242163, 0.49299987,\n 0.41208436, 0.39335919, 0.45047663, 0.40227791, 0.55079414,\n 0.51004866, 0.46107434, 0.44619307, 0.40856549, 0.45213558,\n 0.34076475, 0.44746926, 0.50151825, 0.47512069, 0.44447584,\n 0.51219988, 0.41074984, 0.52785383, 0.37876592, 0.51172916,\n 0.51014685, 0.5534993 , 0.4745541 , 0.49519006, 0.50658855,\n 0.51617094, 0.55167752, 0.52080632, 0.48118055, 0.4497149 ,\n 0.43954218, 0.51988854, 0.46973126, 0.49375973, 0.45512846,\n 0.4670614 , 0.51303675, 0.56130338, 0.49572266, 0.41883276,\n 0.44433704, 0.48790926, 0.50805016, 0.47367689, 0.41275913,\n 0.53529189, 0.4393815 , 0.44798915, 0.47777408, 0.41248419,\n 0.44957019, 0.44111031, 0.47174419, 0.54963872, 0.37056181,\n 0.42624852, 0.42007032, 0.47428632, 0.44194326, 0.53917971,\n 0.51442597, 0.39569021, 0.52024419, 0.45939336, 0.51860329,\n 0.4722443 , 0.49892044, 0.45117057, 0.4687997 , 0.48571876,\n 0.44523495, 0.47080056, 0.40803152, 0.4873699 , 0.42852689,\n 0.5576894 , 0.44129667, 0.48988382, 0.47362904, 0.53799032,\n 0.43168666, 0.47733785, 0.42619853, 0.52326113, 0.40582344,\n 0.3752876 , 0.44395294, 0.43526222, 0.44753265, 0.4335338 ,\n 0.50883482, 0.43585868, 0.41200332, 0.36602514, 0.49333628,\n 0.40624739, 0.45769445, 0.39957451, 0.51484301, 0.45243127,\n 0.49550451, 0.42045661, 0.51606437, 0.45627401, 0.45883254,\n 0.40159611, 0.39777387, 0.47548967, 0.37814115, 0.52078691,\n 0.33737182, 0.49376712, 0.42425788, 0.49313496, 0.51393986,\n 0.33733477, 0.61310296, 0.4179583 , 0.48252206, 0.48776153,\n 0.52774351, 0.48715976, 0.42955008, 0.45700497, 0.43991845,\n 0.45648164, 0.37957614, 0.39961823, 0.43406117, 0.53066173,\n 0.505644 , 0.48217836, 0.49081739, 0.50618318, 0.4919582 ,\n 0.4350554 , 0.48444719, 0.49467042, 0.4789851 , 0.46491457,\n 0.42527415, 0.42989511, 0.47073809, 0.48158046, 0.49392888,\n 0.52054431, 0.47831854, 0.42700402, 0.49578621, 0.52062022,\n 0.43633741, 0.42671723, 0.48976181, 0.41265183, 0.45424771,\n 0.44743247, 0.50648504, 0.46491952, 0.46800249, 0.3828106 ,\n 0.49856068, 0.51699582, 0.48166775, 0.56224234, 0.49789532,\n 0.46000952, 0.49959486, 0.46650966, 0.42187689, 0.47007628,\n 0.51639958, 0.49191647, 0.50020547, 0.51637026, 0.54369003,\n 0.42976058, 0.48321571, 0.47720863, 0.44630105, 0.42892523,\n 0.41553131, 0.46174644, 0.51717268, 0.48445115, 0.44363908,\n 0.486894 , 0.45906175, 0.43506012, 0.44476889, 0.38141848,\n 0.40464606, 0.44997479, 0.44733676, 0.45134756, 0.46831684,\n 0.53670241, 0.47772302, 0.40203076, 0.46568984, 0.39886807,\n 0.55712779, 0.45029969, 0.45676884, 0.55615739, 0.53303594,\n 0.45722586, 0.55022421, 0.48445879, 0.58295224, 0.3706536 ,\n 0.48182352, 0.42183159, 0.44396719, 0.473292 , 0.53361495,\n 0.47621795, 0.44416008, 0.43392763, 0.42497657, 0.48451716])\n\n\n\n## Assignment - Code it up!\n\nMost of the above was pure math - now write Python code to reproduce the results! This is purposefully open ended - you'll have to think about how you should represent probabilities and events. You can and should look things up, and as a stretch goal - refactor your code into helpful reusable functions!\n\nSpecific goals/targets:\n\n1. Write a function `def prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk)` that reproduces the example from lecture, and use it to calculate and visualize a range of situations\n2. Explore `scipy.stats.bayes_mvs` - read its documentation, and experiment with it on data you've tested in other ways earlier this week\n3. Create a visualization comparing the results of a Bayesian approach to a traditional/frequentist approach\n4. In your own words, summarize the difference between Bayesian and Frequentist statistics\n\nIf you're unsure where to start, check out [this blog post of Bayes theorem with Python](https://dataconomy.com/2015/02/introduction-to-bayes-theorem-with-python/) - you could and should create something similar!\n\nStretch goals:\n\n- Apply a Bayesian technique to a problem you previously worked (in an assignment or project work) on from a frequentist (standard) perspective\n- Check out [PyMC3](https://docs.pymc.io/) (note this goes beyond hypothesis tests into modeling) - read the guides and work through some examples\n- Take PyMC3 further - see if you can build something with it!\n\n### Imports\n\n\n```\nfrom scipy import stats\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\n```\n\n### Bayes' Theorem Definition\n\n\n```\ndef prob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk):\n return((prob_positive_drunk*prob_drunk_prior) / prob_positive)\n```\n\n\n```\n# Let's check it\n\nprob_drunk_prior = 1/1000\nprob_positive = 8/100\nprob_positive_drunk = 1\n```\n\n\n```\nprob_drunk_given_positive(prob_drunk_prior, prob_positive, prob_positive_drunk)\n```\n\n\n\n\n 0.0125\n\n\n\n### Likelihood over Ranges of `prob_drunk_prior` and `prob_positive`\n\n\n```\ndf = pd.DataFrame()\n```\n\n\n```\ndrunk_list = list(range(1, 51))\npositive_list = list(range(1, 10, 1))\n\ndrunk_list = [i/100 for i in drunk_list]\npositive_list = [i/100 for i in positive_list]\n```\n\n\n```\ndrunk = []\npositive = []\nlikelihood = []\n```\n\n\n```\nfor x in drunk_list:\n for y in positive_list:\n drunk.append(x)\n positive.append(y)\n likelihood.append(prob_drunk_given_positive(x, y, 1))\n```\n\n\n```\ndf['prob_drunk'] = drunk\ndf['prob_positive'] = positive\ndf['likelihood'] = likelihood\n```\n\n\n```\nfig = plt.figure(figsize=(10, 10))\n\nax = df.plot.scatter('prob_drunk', 'prob_positive', c='likelihood')\n\n# Title\nax.text(x=-.05, y=.11, s=\"Likelihood the Breathylyzer is Correct\", fontsize=14, fontweight='bold');\n\n# Set x-axis label\nplt.xlabel(x=.5, y=-.1, xlabel=\"The proporion of citizens drunk at any given time\", fontsize=12, fontweight=\"bold\", labelpad=15);\nplt.xticks([.1, .2, .3, .4, .5], labels=['.1', '.2', '.3', '.4', '.5']);\n\n# Set y-axis label\nplt.ylabel(x=1, y=.5, ylabel=\"False Positive Rate\", fontsize=12, fontweight=\"bold\", labelpad=15);\nplt.yticks([0, .02, .04, .06, .08, .1]);\n```\n\n### Recursive Definition\n\n\n```\ni = 1\ndf = pd.DataFrame()\nresult = []\nind = []\npost_list = []\n```\n\n\n```\ndef prob_drunk_given_positive_recur(prob_drunk_prior, prob_positive, prob_positive_drunk, n):\n global result\n global i\n \n post_prob = (prob_positive_drunk*prob_drunk_prior) / (prob_positive + prob_drunk_prior)\n ind.append(int(i))\n post_list.append(post_prob)\n #print(i, post_prob)\n i += 1\n while i < n:\n prob_drunk_given_positive_recur(post_prob, prob_positive, prob_positive_drunk, n)\n return(result)\n```\n\n\n```\nprob_drunk_given_positive_recur(prob_drunk_prior, prob_positive, prob_positive_drunk, 20);\n```\n\n\n```\ndf['index'] = ind\ndf['post_prob'] = post_list\n```\n\n\n```\ndf.plot.scatter('index', 'post_prob')\n```\n\nRunning the test over and over again will cause the posterior probability to converge to 1 - (False Positive Rate) as we would expect.\n\n\n```\ndf.head()\n```\n\n\n\n\n\n\n
\n \n \n index \n post_prob \n \n \n \n \n 0 \n 1 \n 0.012346 \n \n \n 1 \n 2 \n 0.133690 \n \n \n 2 \n 3 \n 0.625626 \n \n \n 3 \n 4 \n 0.886625 \n \n \n
\n
\n\n## 4. Level of emission\n____________\n\nEven in this very simple greenhouse model, there is **no single level** at which the OLR is generated.\n\nThe three terms in our formula for OLR tell us the contributions from each level.\n\n\n```python\nOLRterms = sympy.Matrix([OLR_s, OLR_0, OLR_1])\nOLRterms\n```\n\nNow evaluate these expressions for our tuned temperature and absorptivity:\n\n\n```python\nOLRtuned = OLRterms.subs(tuned)\nOLRtuned\n```\n\nSo we are getting about 67 W m$^{-2}$ from the surface, 79 W m$^{-2}$ from layer 0, and 93 W m$^{-2}$ from the top layer.\n\nIn terms of fractional contributions to the total OLR, we have (limiting the output to two decimal places):\n\n\n```python\nsympy.N(OLRtuned / 239., 2)\n```\n\nNotice that the largest single contribution is coming from the top layer. This is in spite of the fact that the emissions from this layer are weak, because it is so cold.\n\nComparing to observations, the actual contribution to OLR from the surface is about 22 W m$^{-2}$ (or about 9% of the total), not 67 W m$^{-2}$. So we certainly don't have all the details worked out yet!\n\nAs we will see later, to really understand what sets that observed 22 W m$^{-2}$, we will need to start thinking about the spectral dependence of the longwave absorptivity.\n\n____________\n\n[Back to ATM 623 notebook home](../index.ipynb)\n
\n\n____________\n## Version information\n____________\n\n\n\n```python\n%load_ext version_information\n%version_information sympy\n```\n\n\n\n\nSoftware Version Python 3.6.2 64bit [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] IPython 6.1.0 OS Darwin 17.7.0 x86_64 i386 64bit sympy 1.1.1 Tue Jan 15 13:50:53 2019 EST
\n\n\n\n____________\n\n## Credits\n\nThe author of this notebook is [Brian E. J. Rose](http://www.atmos.albany.edu/facstaff/brose/index.html), University at Albany.\n\nIt was developed in support of [ATM 623: Climate Modeling](http://www.atmos.albany.edu/facstaff/brose/classes/ATM623_Spring2015/), a graduate-level course in the [Department of Atmospheric and Envionmental Sciences](http://www.albany.edu/atmos/index.php)\n\nDevelopment of these notes and the [climlab software](https://github.com/brian-rose/climlab) is partially supported by the National Science Foundation under award AGS-1455071 to Brian Rose. Any opinions, findings, conclusions or recommendations expressed here are mine and do not necessarily reflect the views of the National Science Foundation.\n____________\n\n\n```python\n\n```\n", "meta": {"hexsha": "1b9720735460637bfdd2752d975535867c40d50e", "size": 166915, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lectures/Lecture07 -- Elementary greenhouse models.ipynb", "max_stars_repo_name": "katrinafandrich/ClimateModeling_courseware", "max_stars_repo_head_hexsha": "6f13fd38706cfef91e81f7e7065d9fab6fb8bb2f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Lectures/Lecture07 -- Elementary greenhouse models.ipynb", "max_issues_repo_name": "katrinafandrich/ClimateModeling_courseware", "max_issues_repo_head_hexsha": "6f13fd38706cfef91e81f7e7065d9fab6fb8bb2f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Lectures/Lecture07 -- Elementary greenhouse models.ipynb", "max_forks_repo_name": "katrinafandrich/ClimateModeling_courseware", "max_forks_repo_head_hexsha": "6f13fd38706cfef91e81f7e7065d9fab6fb8bb2f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 62.0271274619, "max_line_length": 6102, "alphanum_fraction": 0.7476320283, "converted": true, "num_tokens": 7507, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.36658972248186006, "lm_q2_score": 0.2814056194821861, "lm_q1q2_score": 0.10316040795081052}}
{"text": "# Click \"Edit App\" to see the code\n\nPython is a very powerful object oriented programming language, which is used in most fields of science both for computing and for data analysis.\nThis document is a very simplistic introduction to Python written by a non-Python expert, and is designed to be a quick introduction to Python for CHEM2000 students.\nIn many places the nomenclature is likely to be inaccurate and you are encouraged to consult more rigorous resources developed by real Python programmers.\n\nThis document is aimed at providing enough knowledge to solve all the numerical laboratories that are part of the CHEM2000 unit using Python, but it is far from comprehensive. There are many different ways to solve problems numerically, different libraries/packages can be used and here we are providing only one (or a few) possible way of doing things.\n\nThe entire document and the examples therein have been developed using a **Jupyter Notebook**, and work best there.\n\nA Jupyter notebook consists of a series of cells that can be either _text_ or _code_, the cell can then be _executed_ by pressing the **run** button or _Shift+Return_ (if you want to look like a pro). If things go pear-shaped, restarting the kernel and rerunning all the cells may help; this can be done by pressing the _fast forward_ button.\n\nText cells accept _Markdown_ syntax and once executed will render the text. Markdown provides a simple way of producing formatted text and it accept _LaTeX_ commands for equations, which look much nicer that those made with the equation editor in MS Word. For a Markdown tutorial click [here](https://www.markdowntutorial.com)\n\nThe code cells contain Python 3 commands. Note that some Python 3 is different from Python 2, _e.g._ the **print** command works differently.\n\n# My first Jupyter Notebook\nIn general you would use the first _code_ cell to import all the packages that we need to use in the remainder of the code. We can import entire packages, part of the packages and assign aliases to the package name, _e.g._\n\n\n```python\n# python packages\nimport pandas as pd # Dataframes and reading CSV files\nimport numpy as np # Numerical libraries\nimport matplotlib.pyplot as plt # Plotting library\nfrom lmfit import Model # Least squares fitting library\n```\n\nthis is particularly important because it ensures that if we define a variable that has the same name of a function belonging to that package there is no confusion about what the code does.\n```python\n# This is a variable\nmean = 10 \n\n# This is the NumPy function to compute the mean of an array of numbers\nnp.mean([1,2,3])\n```\n\nThings to keep in mind when programming in Pythons are\n\n1. It is Case sensitivE\n\n```python\naverage = 0\n```\nis different from\n```python\naVeRagE = 0\n```\n\n2. Variables' names cannot have spaces. This line would give you a _syntax error_\n```ptyhon\nnumber of values = 10\n```\n\n3. Spaces between operators are ignored, _1+2_ is the same as _1 + 2_\n\n\n```python\nprint(1 + 2)\nprint(1+2)\n```\n\n4. \\# is a comment and everything on its right is ignored\n\n\n```python\n# This is a comment\nprint(\"Hello world\") # This is also a comment\n```\n\n5. A single command can spread over multiple lines. If we split the line between variables no continuation line character is required. Otherwise we can use the \"\\\" character. Note the different results of the two commands below.\n\n\n```python\nprint(\"Hello\", \n \"world\")\nprint(\"Hello \\\n world\")\n```\n\n6. Indentation matters! Indentation is used to define the content of loops, functions... This will be more clear when we start using functions.\n\n# Good programming practices\n\n1. Use meaningful name for your variables so that you know what's inside, there is no character limit.\n2. Use a consistent style and convention for your variables, the code will look neater. I like to use the _camel case_ style (numberOfValues) that allows me to have separation between words without using spaces. Alternatively you can use the _Pascal case_ style (NumberOfValues) or use the underscore character to separate words (number_of_variables) or create your own style.\n3. Comment your code well, it may be obvious what it does when you write it, but it won't be so obvious after a year or more.\n\n# Python as a simple calculator\n\nLet's start by doing some simple mathematical operations using this Jupyter Notebook; addition, multiplication, division $\\dots$, just to get familiar with the Jupyter Notebook.\n\n\n```python\n2 + 3\n```\n\n\n```python\n4 * 3\n```\n\n\n```python\n12 / 3\n```\n\n\n```python\n2**3\n```\n\nThe same operations can be done using variables. We can first define two variables _a_ and _b_ and then use them in in the following cells\n\n\n```python\na = 12\nb = 3\na + b\n```\n\nThis is not a very efficient way of working because the result of the operation is not available to the rest of the code after the cell has been executed. Typically, we want to create new variables and than write the result using the _print_ command.\n\n\n```python\na = 10\nb = 20\nc = a + b\nprint(\"Result :\",c)\n```\n\n# Python as a scientific calculator\nNot all scientific operators are natively available in Python, but they can be accessed through optional packages that are loaded at the beginning of your notebook, _e.g._ **NumPy**.\nNumPy is one of the most commonly used Python libraries, it contains all the operators for square root, logarithm, exponential, the trigonometric function, a suite of constants and much more. \nFor more information see [https://numpy.org](https://numpy.org).\n\nIn the examples below we show how to use NumPy to access some of these functions.\n* Note that we access the NumPy function through using the _np_ prefix because of the way we imported the NumPy library at the beginning of this notebook.\n\n\n```python\nprint(\"The approximate value of pi is :\",np.pi)\nprint(\"The approximate value of the Euler constant (e) is :\",np.e)\nprint(\"The square root of two is :\",np.sqrt(2))\nprint(\"The natural logarithm of two is :\",np.log(2))\nprint(\"The logarithm base 10 of two is :\",np.log10(2))\nprint(\"The sine of pi is :\",np.sin(np.pi))\nprint(\"The cosine of pi is :\",np.cos(np.pi))\n```\n\nEven more useful than variables are arrays, which allow us to store many values in one place. Arrays can be created by hand or be the output of other Python functions.\nThey can contain numbers, strings or other variables, or mixed types\n\n\n```python\narrayOfNumbers = [300, 2, 3.2]\nprint(\"Three dimensional array of numbers :\",arrayOfNumbers)\narrayOfStrings = [\"Temperature\" , \"Pressure\" , \"Volume\"]\nprint(\"Three dimensional array of strings :\",arrayOfStrings)\nmixedArray = [\"temperature\" , 300]\nprint(\"The mixed array is :\",mixedArray)\n```\n\nWe can easily access one of the elements of the array, by specifying its location in the array.\n* Note that Python starts counting from zero!\n\n\n```python\nprint(\"Second element of the array of numbers :\",arrayOfNumbers[1])\nprint(\"Second element of the array of strings :\",arrayOfStrings[1])\n```\n\nWe can also construct a loop to cycle over the elements of the array.\nIf we are interested in cycling over one array only we can use the **in** operator.\n* It's important to note here that the indentation of the code determines where the loop finished\n\n\n```python\nfor value in arrayOfNumbers:\n print(\"--- This is inside the loop ----\",value)\nprint(\"--- This is outside the loop ---\")\n```\n\nAlternatively we can create a loop over the indices of the array using the **range** iterator.\n* Note the use of the function **len** to compute the size of the array!\n* Note that the upper limit of the **range** iterator is not included!\n\n\n```python\nnumberOfElements = len(arrayOfNumbers)\nprint(\"Number of elements :\",numberOfElements)\nfor index in range(0,numberOfElements):\n print(index, # index\n arrayOfStrings[index], # sting\n arrayOfNumbers[index]) # number\n```\n\n**range** is a special thing of python 3, and it produces a list of indices only when part of a loop. This is at variance with the NumPy **arange** function, which instead will produce an array that we can use normally.\nBoth the **range** and **arange** function typically take three arguments, the lower limit of the range (included) the upper limit of the range (not included) and the step. The main difference is that **range** being an iterator works only with integer numbers, while **arange** can also work with floating point numbers. \nIf the step is omitted, one is assumed.\nLet's have a look at a couple of examples.\n\n\n```python\nfor i in range(0,4):\n print(i)\n```\n\n\n```python\nfor i in range(0,4,2):\n print(i)\n```\n\n\n```python\nfor i in np.arange(0,4,2):\n print(i)\n```\n\n\n```python\nfor i in np.arange(0,4,0.5):\n print(i)\n```\n\nLet's now see how we can use the **range** iterator and the **np.arange** function to generate arrays of equally spaced values. While this is straightforward with the NumPy function, it is more complicated with **range** iterator, and we need to _recast_ the output into a list.\n\n\n```python\nvalues = np.arange(1.1,4,0.7)\nprint(values)\n\nvalues = list(range(0,5,2))\nprint(values)\n```\n\n# Operations with arrays\nAs an illustrative example of using arrays and variables we can now compute the sum and average of all the elements in an array of numbers. In order to do that we initialise a variable to zero, and progressively add the array elemnts to it.\n* Note how we can increment the value of the variable using the += operator. These two commands are equivalent\n```python\nsumm += value\nsumm = summ + value\n```\nThose two line are also equivalent to the following, where we use a temporary variable, to explicitly show what the code does\n```python\ntmp = summ + value\nsumm = tmp\n```\nThe operators -=, \\*= and /= have analogous meanings.\n\n\n```python\nsumm = 0.\nfor value in arrayOfNumbers:\n summ += value \n\nprint(\"Result of += :\",summ)\n```\n\nThe average can then be computed directly inside the print statement.\n\n\n```python\nprint(\"Average :\",summ/len(arrayOfNumbers))\n```\n\nMany simple operations on arrays can however be more efficiently performed using libraries such as NumPy, _e.g._ summation, average, standard deviation, etc.\nUsing these function will also make your code slimmer and easier to read.\n\n\n```python\ntally = np.sum(arrayOfNumbers)\naverage = np.mean(arrayOfNumbers)\nStDev = np.std(arrayOfNumbers)\n\nprint(\"Sum :\",tally)\nprint(\"Average :\",average)\nprint(\"Standard Deviation :\",StDev)\n```\n\nUnfortunately there is no NumPy function for computing the standard error, but we can easily compute that from its definition\n\n\\begin{equation}\nStdErr = \\frac{\\sigma}{\\sqrt{N}}\n\\end{equation}\nwhere $\\sigma$ is the standard deviation and $N$ the number of values used in the calculation.\n\n\n```python\nprint(\"Standard Error :\",StDev/np.sqrt(len(arrayOfNumbers)))\n```\n\n# Using DataFrames\nDataframes are powerful objects that are part of the _pandas_ package. The most simplistic description of a dataframe is that it is a multi-dimension mixed array. Dataframes are more than that, as they also include functions that operate on the DataFrame content.\nThis definition of DataFrames would probably horrify a Python programmer, but it would suffice for the purpose of this course.\n\nDataframes can be defined by hand, or created by other functions, _e.g._ by reading a Comma Separated Values file (.csv). Let's see first how we can create a an empty DataFrame, with three columns named \"Temperature\", \"Volume\" and \"Pressure\"; with their units.\n\n\n```python\n# This array is used to define the names of the columns\nheader = [\"Temperature (K)\" , \"Volume (L)\" , \"Pressure (bar)\"] \n\n# This is our new dataframe\ndf = pd.DataFrame(data=None, columns=header)\nprint(df)\n```\n\nLet's now fill the dataframe using the ideal gas law\n\n\\begin{equation}\npV = nRT\n\\end{equation}\n\nwhere $p$ is the pressure, $V$ the volume, $T$ the temperature and $R=8.314\\ J/mol/K$ is the ideal gas constant, each expressed with the units specified in the header of the dataframe.\n\nLet's compute the volume of an ideal gas at different pressures and temperatures.\n\nFor simplicity we fix the number of moles to 1.\n* Note how we use the **range** function to create an array of integers and the NumPy **arange** function to create a an array of _floating point numbers_.\n* The variable _index_ is used to count the number of elements that we already have in the DataFrame, and to add the next one. This works because Python starts counting from zero.\n* Note we used the **loc** function to added an array to the DataFrame at a specific position.\n* Note how we also created an array to store all the temperatures we generate, the array is created empty using **= []** and then we append elements to it using the **.append()** function\n\n\n```python\nR = 8.314 # kJ/mol\nn = 1\n# Conversion factor between J/bar to litre\nconversionFactor = 0.01 \n\nlistOfTemperatures = []\nfor T in range(100,301,50):\n listOfTemperatures.append(T)\n \n for p in np.arange(0.1,1,0.02):\n V = (n * R * T / p) * conversionFactor \n index = len(df.index)\n df.loc[index] = [T , V , p] # a vector is added to the DataFrame\n \nprint(df)\n```\n\nThere are many ways to access the data in a DataFrame. Here we'll show you two; one to quickly get an entire column of the array, and one to get selected chunks of data using the **iloc** function.\n\n\n```python\nprint(df[\"Temperature (K)\"])\n```\n\nFor the DataFrame that we have, the **iloc** function takes two arguments, the row and columns indices.\n\n\n```python\nprint(df.iloc[0,1])\n```\n\nWe can then use \"**:**\" to specify a range of elements that we want to use.\n* Note that the lower limit of the range is included while the upper limit is not !\n* Note that if one limit of the range is missing, the start/end of the array is assumed\n* Note how we have used **.values** to cast the output data in an array.\n\n\n```python\nprint(df.iloc[0:3 , 1 ].values) # the first three volumes\nprint(df.iloc[0 , 0:3].values) # the first row\nprint(df.iloc[0 , : ].values) # the first row\nprint(df.iloc[0 , 1: ].values) # the last two elements of the first row\nprint(df.iloc[0 , :2].values) # the first two elements of the first row\n```\n\n# Making a graph\nLet's now make a graph with these data using the **mathplotlib** library. \nAs a start we can make a plot of the entire DataFrame.\n\nThe **subplots** function creates two objects, the _figure_ and the _axes_ of the figure itself.\nEach of those objects contain functions that we can use to customise the final plot. More in another tutorial.\n\n\n```python\n# Create the figure and axes objects\nfig , ax = plt.subplots()\n# Add the data to the plot from the DataFrame\nax.scatter(df[\"Pressure (bar)\"] , df[\"Volume (L)\"])\n# Diplay the figure\nplt.show()\n```\n\nLet's now do some data manipulation to make a better plot, using a line for each isotherm.\nThere are many ways of doing this, but here we'll take an educational approach and use _conditional_ statements to select parts of the dataframe, add them to arrays and plot them.\n\nWhat we are going to do is to choose a temperature, _e.g._ 100K, and create two arrays (p,v) with the corresponding pressures and volumes, than we will use them for plotting.\n* Note that we used the **scatter** and **plot** functions to plot the data as circles with a line overlaid.\n* Note that we set the **set** function for to add the labels to the axes (_ax_)\n\n\n```python\nT=100\npressure = []\nvolume = []\nfor index in range(0,len(df.index)):\n if df.iloc[index,0] == T:\n pressure.append(df.iloc[index,2])\n volume.append(df.iloc[index,1])\n\nprint(\"Pressure array :\",pressure[0:3],\"...\")\nprint(\"Volume array :\",volume[0:3],\"...\")\n\nfig , ax = plt.subplots()\nax.scatter(pressure , volume)\nax.plot(pressure , volume)\n\n# Let's add the labels to the axes\nax.set(xlabel=\"Pressure (bar)\")\nax.set(ylabel=\"Volume (L)\")\n\nplt.show()\n```\n\nIf we want then to plot all isotherm in one graph we can wrap the code above in a loop over all the temperatures we have created. \n\n* Note the indentation of the **for** loops and **if** conditional statement.\n* Note how in this example we select portions of the DataFrame including a conditional statement in **[]** when we call the DataFrame\n* Note that we used **.values** to transform the DataFrame into an array\n\n\n```python\n# First we have to create the figure\nfig , ax = plt.subplots()\n\nfor T in listOfTemperatures:\n pressure = df[df[\"Temperature (K)\"] == T][\"Pressure (bar)\"].values\n volume = df[df[\"Temperature (K)\"] == T][\"Volume (L)\"].values\n\n # add one line to the plot for each temperature\n ax.plot(pressure , volume, label=T)\n\n# Let's add the labels to the axes\nax.set(xlabel=\"Pressure (bar)\")\nax.set(ylabel=\"Volume (L)\")\n\n# Let's also add the legend\nax.legend()\n\nplt.show()\n```\n", "meta": {"hexsha": "314ec75f646c6903882ddc72af170db54c82f345", "size": 26589, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "codeSnippets/0_introductionToPython.ipynb", "max_stars_repo_name": "praiteri/TeachingNotebook", "max_stars_repo_head_hexsha": "75ee8baf8ef81154dffcac556d4739bf73eba712", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "codeSnippets/0_introductionToPython.ipynb", "max_issues_repo_name": "praiteri/TeachingNotebook", "max_issues_repo_head_hexsha": "75ee8baf8ef81154dffcac556d4739bf73eba712", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "codeSnippets/0_introductionToPython.ipynb", "max_forks_repo_name": "praiteri/TeachingNotebook", "max_forks_repo_head_hexsha": "75ee8baf8ef81154dffcac556d4739bf73eba712", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-02-23T11:36:12.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-23T11:36:12.000Z", "avg_line_length": 32.9071782178, "max_line_length": 385, "alphanum_fraction": 0.592839144, "converted": true, "num_tokens": 4040, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.21469141911224193, "lm_q2_score": 0.48047867804790706, "lm_q1q2_score": 0.10315464924327918}}
{"text": "\n\n **Light and Optics** Gif taken from https://giphy.com/gifs/fandor-sun-eclipse-3o7OsM9vKFH2ESl0KA/links, August 1st, 2018. \n Figure 1: For hundreds of years, scientists have tried to understand the nature of light. With advances in technology, and inventions like telescopes, we have been able to see farther than ever before. \n\n***\n\n## Introduction\n\nThroughout most of history, humans did not understand light as we do today. As science and technology have progressed over time, so too has our knowledge of the nature of light. \n\nIn this lesson, when we say the word \"light\", we will be referring to visible light (light that comes from the sun, lightbulbs etc.). We will go over how a few key experiments kickstarted a new way of thinking, and a few of the ways that we are able to manipulate light. We will also talk about how our eyes enable us to see.\n\n## Background\n\nIf you had to describe to someone what light is, you may have a hard time. Some people think of light as the absence of darkness, but even that doesn't say much about light itself.\n\nOur understanding of light truly began around the 17th century, when a few individuals started to realize that light was not a mystical substance. Scientists (or \"natural philosophers\", as they were called during that time) recognized that certain properties of light were measurable, and that some properties could be manipulated. Sir Isaac Newton and Ole Rømer were among the first scientists to take a step in this direction.\n\n\n> ### Isaac Newton's Prism Experiment\n\nSir Isaac Newton has made contributions to many fields of science and mathematics. In 1666, while spending time at his childhood home in Lincolnshire, England, Newton began experimenting with light. \n\nUsing a small slit in his window shutters, Newton passed a narrow beam of sunlight through a glass prism. The light travelled through the prism, and projected a rainbow of color on the other side!\n\n\nPicture taken from http://lightingmatters.com.au/wp/what-is-the-colour-of-white/white-light-prism-experiment/, July 30th, 2018. \n Figure 2: This picture shows how a prism can create a spectrum of color. This is what Newton would have seen in 1666. \n\nLater on, scientists determined that the prism was actually splitting light into its component parts. This phenomenon is called **dispersion**.\n\nThrough this experiment, Newton demonstrated that white light was actually made up of all the individual colors of the rainbow!\n\n> ### Ole Rømer and the Speed of Light\n\nFor many years, people thought that if somebody lit a match, the light from that match would be instantly visible to everyone, no matter how far away they were. However, in 1676 Ole Rømer proved that this is not the case.\n\nRømer spent a long time studying the orbit of Io, one of Jupiter's moons. As part of his study, he began predicting the times when Io should be hidden behind Jupiter's shadow (these periods are called eclipses). However, Rømer saw that his predictions for when these eclipses should occur were not always accurate. \n\n\nGif taken from https://giphy.com/gifs/timelapse-DXIa1beDspYRy, August 1st, 2018. \n Figure 3: Here we can see Jupiter as it looks through a telescope. You might be able to see a black spot move from the left to the right across Jupiter's surface. This is actually one of Jupiter's many moons! \n\nRømer then realized that these errors may be because the distance between Io and the Earth was always changing. Rømer thought that when the distance between Io and the Earth increased, it might take a longer time for light coming from Io to reach Earth. If this were the case, then the light must be travelling at a finite speed!\n\nAfter taking many measurements and using some clever mathematics, Rømer calculated the speed of light to be roughly 220,000,000 m/s, or 792,000,000 km/h.\n\nToday, we have measured the speed of light to be 299,792,458 m/s. Although he was not exactly right, Rømer provided one of the first mathematical calculations for the speed of light. \n\n***\nSince the time of Rømer and Newton, scientists have made many new discoveries about the nature of light. While not all of these discoveries agree with one another, here are two things we know for sure:\n- Light is made up of a spectrum of color\n- Light travels at a speed of 299,792,458 m/s\n\nNow let's talk about some of the ways we can manipulate light.\n***\n\n## Reflection\n\nWe are all familiar with reflection; chances are, you look at your reflection more than once a day. But have you ever stopped to wonder what is really going on? \n\nReflection is the term used to describe how light can change direction when it comes into contact with certain surfaces. \n\nWhen incoming light rays encounter a reflective surface, they bounce off the surface and continue moving in a new direction. The new direction in which it moves is determined by the **law of reflection**.\n\n\\begin{equation} \n\\rm Law\\: of\\: Reflection: Angle\\: of\\: Incidence = Angle\\: of\\: Reflection\n\\end{equation}\n\nOn the animation below, click on the flashlight to turn it on, and move your mouse to change the angle of incidence.\n\n\n```python\nIFrame('Animations/reflect.html',width=500,height=320)\n```\n\nAs seen above, the **normal** is what we call the line that forms a 90$^{\\circ}$ angle with the surface. The **angle of incidence** is what we call the angle between the flash lights beam and the normal. Similarly, the **angle of reflection** is the angle that the newly reflected light beam makes with the normal. The law of reflection states that these two angles will always be equal.\n\n\n\n## Refraction\n\nHave you ever tried to reach down and grab an object sitting at the bottom of a pool of water? If you have, you may have noticed that the object isn't actually in the location that you thought it was.\n\n\n Image taken from http://legacy.sciencelearn.org.nz/Contexts/Light-and-Sight/Sci-Media/Video/Refraction/(quality)/hi on August 3rd, 2018. \n Figure 4: When you are looking into a body of water from above, the objects you see beneath the surface are not actually where they appear to be. \n\nThis phenomenon occurs because the light travelling to your eyes from the bottom of the pool **refracts**, or changes its direction of travel, when it transitions from water to air. \n\nThe **index of refraction** is a value that we use to show how much light will bend when travelling through a substance. For example, the index of refraction for air is approximately 1.00, and the index of refraction for water is about 1.33. Because these indexes are different, light will bend when passing from water to air, or vice versa.\n\nUse the animation below to see how light refracts when passing from air to water. Click on the flashlight to turn it on.\n\n\n```python\nIFrame('Animations/refract.html',width=520,height=320)\n```\n\nMathematically, reflection can be described using the following equation, known as Snell's Law:\n\n\\begin{equation} \n\\textrm{Snells Law:}\\: n_1\\sin(\\theta_1) = n_2\\sin(\\theta_2)\n\\end{equation}\n\nwhere $n_1$ is the index of refraction for the first medium, $\\theta_1$ is the incident angle, $n_2$ is the index of refraction for the second medium, and $\\theta_2$ is the angle of refraction.\n\nLight will bend *towards* the normal when travelling from a medium with a *lower* index of refraction to one with a *higher* index of refraction, and vice versa.\n\n***\nSome of the most beautiful sights in nature are caused by reflection and refraction. Here are a couple of examples:\n\n### Rainbows\n\nRainbows are a result of both reflection and refraction. As its raining, each water droplet acts like a tiny prism, just like the one we saw in Figure 2. The water droplets split visible light into colors, and these colors are then reflected back towards our eyes. \n\n\n Image taken from https://waterstories.nestle-waters.com/environment/how-does-a-rainbow-form/ on August 3rd, 2018. \n Figure 5: Water droplets use reflection and refraction to create the beautiful rainbows that we see while it is raining. \n\n\n\n### Mirages\n\nHave you ever been driving on a sunny day, and up ahead it looks as though a stream of water is running across the road? You are really seeing a mirage.\nMirages also occur because of refraction, but they do not result in a display of color like a rainbow. This type of refraction occurs due to a difference in temperature between separate layers of air.\n\nAs we were describing before, refraction occurs when light travels from one substance to another. Well, it turns out that hot air and cold air are actually different enough to act as different substances. Therefore, light will refract when passing through one to the other. \n\n\n Image taken from https://edexcellence.net/articles/what-the-mirage-gets-wrong-on-teacher-development on August 3rd, 2018. \n Figure 6: Although it may look like water running across the road, it is actually a mirage. These commonly occur in desert areas, where the road can become very hot. \n\nWhen you are looking at a mirage, it can look as though the air is wavy and fluid, which is why it is common to think that you are looking at water. This appearance occurs when layers of hot and cold air are mixing together, and light passing through these layers is constantly being refracted in different directions.\n\nYou may see a mirage appear on top of a hot roadway, behind the exhaust pipe of a plane or car, or around any other source of heat.\n\n## Applications of Reflection and Refraction\n\n### Lenses\n\nIf you have glasses, or contact lenses, then you are constantly using refraction in order to help you see! Lenses use refraction to point light in specific directions.\n\nGenerally speaking, there are two types of lenses: **convex** and **concave**.\n\nTo see how each type of lense affects light, use the following animation.\n\n\n```python\nIFrame('Animations/convex.html',width=520,height=420)\n```\n\nAs seen above, a convex lens focuses light towards a specific point, while a concave lens will spread light away from a point. These lenses can be combined in many ways in order to produce different effects. For example, a camera lens uses a series of both convex and concave lenses in order to direct incoming light towards the back of the camera.\n\n\n Image taken from https://www.reddit.com/r/pic/comments/3o3b7w/camera_lens_cut_in_half/ on August 3rd, 2018. \n Figure 5: This is what the inside of a camera lens looks like. The photographer can adjust how they want the picture to look by changing the distance between the individual lenses. \n\n\n\n\n## Vision\n\nOur eyes are very complex organs, but the process that enables us to see is actually pretty simple. The basic steps are as follows:\n\n1. Light enters the eye through the **pupil**\n2. The convex **lens** behind the pupil directs incoming light towards the **retina**, which is like a screen at the back of our eye.\n3. The retina then sends this image to the brain.\n4. The brain then interprets the image. \n\n\n Image taken from https://openclipart.org/detail/261647/eye-diagram on August 3rd, 2018. \n Figure 6: This diagram shows some of the key components of the eye that enable us to see. \n\nHowever, the image that is projected onto the retina is actually upside down! \n\n\n Image taken from https://www.eetimes.com/author.asp?section_id=14&doc_id=1282795 on August 3rd, 2018. \n Figure 7: The convex lens at the front of our eye actually flips images upside down. \n\nSo the retina actually sends an upside down image to the brain, and the brain automatically flips the image rightside up.\n\nUse the following link to see an animation showing how a convex lens flips images upside down:https://phet.colorado.edu/sims/geometric-optics/geometric-optics_en.html.\n\n\n## Technology & Inventions\n\n### The Telescope\n\nThe first telescope was made by Hans Lippershey in 1608, but it was Galileo Galilee who became famous by using it for astronomy. There are many different types of telescopes, but they all use reflection and refraction to make far away objects appear closer.\n\nA telescope uses a large opening to collect incoming light, and then directs this light towards your eye by using mirrors and lenses.\n\n\n Image taken from https://www.skyandtelescope.com/press-releases/tips-for-first-time-telescope-buyers/ on August 3rd, 2018. \n Figure 8: Telescopes come in many different shapes and sizes. \n\nThe reason why things look bigger when looking through a telescope is because of the lenses.\n\n\n### The Microscope\n\n\n- talk about invention of microscope\n- why it works\n\n\n## Conclusion\n\nOur understanding of light is the result of hundreds of years of research and innovation. Along the way, we have created incredible new technologies that have allowed us to look further than ever before.\n\n\n Image taken from https://xenlife.com.au/hubble-space-telescope-important/ on August 3rd, 2018. \n Figure 9: The Hubble Space Telescope has shown us pictures of galaxies that are billions of light years away. \n \n\n\n\n[](https://github.com/callysto/curriculum-notebooks/blob/master/LICENSE.md)\n", "meta": {"hexsha": "ea8f1dfdb26925dcebdb89d4624c2fd716cec61d", "size": 19793, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_sources/curriculum-notebooks/Science/LightOpticalSystems/light-optical-systems.ipynb", "max_stars_repo_name": "mlamoureux/CallystoJBook", "max_stars_repo_head_hexsha": "058080e1bb6370c0a072ed1c0ded96fe1e2947de", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "_sources/curriculum-notebooks/Science/LightOpticalSystems/light-optical-systems.ipynb", "max_issues_repo_name": "mlamoureux/CallystoJBook", "max_issues_repo_head_hexsha": "058080e1bb6370c0a072ed1c0ded96fe1e2947de", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_sources/curriculum-notebooks/Science/LightOpticalSystems/light-optical-systems.ipynb", "max_forks_repo_name": "mlamoureux/CallystoJBook", "max_forks_repo_head_hexsha": "058080e1bb6370c0a072ed1c0ded96fe1e2947de", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 19793.0, "max_line_length": 19793, "alphanum_fraction": 0.7164654171, "converted": true, "num_tokens": 3351, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.41489884579676883, "lm_q2_score": 0.24798742068237775, "lm_q1q2_score": 0.10288969461323628}}
{"text": "```python\n%matplotlib widget\n\nimport matplotlib\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport mplcursors\n```\n\n\n```python\n# Scale plot to fit page \nplt.rcParams[\"figure.figsize\"] = (8, 6)\nplt.rcParams[\"font.size\"] = 18\n```\n\n# Radiation Interatctions with Matter\n\n### Learning Objectives\n\n- Define uncollided flux\n- Define linear interaction coefficient\n- Apply linear interaction coefficients to a slab problem\n- Identify the units of intensity, flux density, fluence, reaction rate\n- Compare linear interaction coefficient and cross section\n- Calculate uncollided flux in a medium \n- Calculate mean free path of a particle in a medium\n- Define the half thickness in a medium\n- Apply the concept of buildup factor to attenuation in a slab\n- Define microscopic cross section\n- Calculate macroscopic cross sections, given a microscopic cross section\n- Calculate the mass interaction coefficients of mixtures\n- Calculate flux density\n- Calculate Reaction Rate Density\n- Recognize the dependence of flux on energy, position, and time\n- Define radiation fluence\n- Calculate uncollided flux density from isotropic point sources\n- Apply the Kelin-Nishina formula to Compton Scattering\n- Compare energy dependence of photon interaction cross sections\n- Describe energy dependence of neutron interaction cross sections\n- Recognize the comparative range of heavy vs. light particles \n- Recognize the comparative range of charged particles\n\n## Linear Interaction Coefficient\n\n- The interaction of radiation with matter is always statistical in nature, and, therefore, must be described in probabilistic terms. \n\nConsider a particle travelling through a homogeneous material.\n\n\\begin{align}\nP_i(\\Delta x) &= \\mbox{probability the particle, causes a reaction of type i in distance }\\Delta x\\\\\n\\end{align}\n\nEmpirically, we find that this probability becomes constant as $\\Delta x \\longrightarrow 0$. Thus:\n\n\n\\begin{align}\n\\mu_i &= \\lim_{\\Delta x \\rightarrow 0}\\frac{P_i(\\Delta x)}{\\Delta x}\\\\\n\\end{align}\n\nFacts about $\\mu_𝑖$:\n\n- $\\mu_i$ is an *intrinsic* property of the material for a given incident particle and interaction. \n- $\\mu_i$ is independent of the path length traveled prior to the interaction. \n- $\\mu_i$ may represent many types of interaction (scattering: $\\mu_s$, absorption: $\\mu_a$, ...)\n- $\\mu_i$ typically depends on particle energy\n\n\nThe probability, per unit path length, that a neutral particle undergoes some sort of reaction, is the sum of the probabilities, per unit path length of travel, for each type :\n\n\\begin{align}\n\\mu_t(E) = \\sum_i \\mu_i(E)\n\\end{align}\n\n## Think Pair Share:\n\nWhat are the units of the linear interaction coefficient?\n\n### Attenuation of Uncollided Flux\n\nImagine a plane of neutral particles strike a slab of some material, normal to the surface. \n\nWe can describe this using $\\mu_t$ or, equivalently, the macroscopic total cross section $\\Sigma_t$. \n\n\n\\begin{align}\nI(x) &= I_0e^{-\\mu_t x}\\\\\nI(x) &= I_0e^{-\\Sigma_t x}\\\\\n\\end{align}\n\nwhere\n\n\\begin{align}\n I(x) &= \\mbox{uncollided intensity at distance x}\\\\\n I_0 &= \\mbox{initial uncollided intensity}\\\\\n \\mu_t &= \\mbox{total linear interaction coefficient} \\\\\n \\Sigma_t &= \\mbox{macroscopic total cross section} \\\\\n x &= \\mbox{distance into material [m]}\\\\\n\\end{align}\n\n\n\n```python\nimport math\ndef attenuation(distance, initial=100, sig_t=1):\n \"\"\"This function describes neutron attenuation into the slab\"\"\"\n return initial*math.exp(-sig_t*distance)\n\n```\n\nRather than intensity, one can find the probability density:\n\nWe have a strong analogy between decay and attenuation, as above. In the case of decay the probability of decay in a time interval dt is:\n\n\\begin{align}\nP(t)dt &= \\lambda e^{-\\lambda t}dt\\\\\n &= \\mbox{probability of decay in interval dt}\n\\end{align}\n\nFrom this, one can find the mean lifetime of a neutron before decay:\n\n\\begin{align}\n\\bar{t} &= \\int_0^\\infty t'P(t')dt'\\\\\n &= \\int_0^\\infty t'\\lambda e^{-\\lambda t'}dt'\\\\ \n &= \\frac{1}{\\lambda}\n\\end{align}\n\nIn the case of attenuation:\n\\begin{align}\nP(x)dx &= \\Sigma_te^{-\\Sigma_tx}dx\n\\end{align}\n\nSuch that: \n\n\\begin{align}\nP(x)dx &= \\mu_t e^{-\\mu_t x}dx\\\\\n &= \\Sigma_t e^{-\\Sigma_t x}dx\\\\\n &= \\mbox{probability of interaction in interval dx}\n\\end{align}\n\n\nSo, the mean free path is:\n\n\\begin{align}\n\\bar{l} &= \\int_0^\\infty x'P(x')dx'\\\\\n &= \\int_0^\\infty x'\\Sigma_te^{-\\Sigma_t x'}dx'\\\\ \n &= \\frac{1}{\\Sigma_t}\n\\end{align}\n\n\nOr, equivalently in $\\mu_t$ notation:\n\n\\begin{align}\n\\bar{x} &= \\int_0^\\infty x'P(x')dx'\\\\\n &= \\int_0^\\infty x'\\mu_te^{-\\mu_t x'}dx'\\\\ \n &= \\frac{1}{\\mu_t}\n\\end{align}\n\n\n\n```python\ndef prob_dens(distance, initial=100, sig_t=1):\n return sig_t*attenuation(distance, initial=100, sig_t=1)\n\n```\n\n\n```python\nsig_t = 0.2\ni_0 = 100\n\n# This code plots attenuation\nimport numpy as np\nz = np.arange(24)\ny = np.arange(24)\nx = np.arange(24)\nfor h in range(0,24):\n x[h] = h\n y[h] = attenuation(h, initial=i_0, sig_t=sig_t)\n z[h] = prob_dens(h, initial=i_0, sig_t=sig_t)\n\n# creates a figure and axes with matplotlib\nfig, ax = plt.subplots()\nscatter = plt.scatter(x, y, color='blue', s=y*20, alpha=0.4) \nax.plot(x, y, color='red') \nax.plot(x, z, color='green') \n\n\n# adds labels to the plot\nax.set_ylabel('Percent of Neutrons')\nax.set_xlabel('Distance into slab')\nax.set_title('Attenuation')\n\n# Add mpl widget for interactivity\nlabels = ['{0}% intensity'.format(i) for i in y]\nmplcursors.cursor(ax).connect(\n \"add\", lambda sel: sel.annotation.set_text(labels[sel.index]))\n\nplt.show()\n```\n\n## Half-thickness\n\nIn another analog to decay, the **half-thickness** of a material is the distance required for half of the incident radiation to interact with a medium:\n\n\\begin{align}\n\\frac{I(x_{1/2})}{I(0)} &= e^{-\\mu_t x_{1/2}}\\\\\n\\implies x_{1/2} &= \\frac{\\ln{2}}{\\mu_t}\n\\end{align}\n\n## Think pair share: \nWhat is the concept in the context of decay that is analogous to the half-thickness?\n\n\n## Microscopic and Macroscopic Cross Sections\n\n- The microscopic cross section $\\sigma_i$ is the likelihood of the event per unit area. \n- The macroscopic cross section $\\Sigma_i$ is the likelihood of the event per unit area of a certain density of target isotopes.\n- The macroscopic cross section $\\Sigma_i$ is equivalent to the linear interaction coefficient $\\mu_i$, but we tend to use $\\Sigma_i$ in nuclear interactions, reserving $\\mu_i$ for photon interactions.\n\n\\begin{align}\n\\mu_i &= \\mbox{linear interaction coefficient}\\\\\n\\Sigma_i &= \\mbox{macroscopic cross section}\\\\\\\\\n &= \\sigma_i N\\\\\n &= \\sigma_i \\frac{\\rho N_a}{A}\\\\\n \\mbox{where }& \\\\\n N &= \\mbox{atom density of medium}\\\\\n \\rho &= \\mbox{mass density of the medium}\\\\\n N_a &= \\mbox{Avogadro's number}\\\\\n A &= \\mbox{atomic weight of the medium}\n\\end{align}\n\n\n\n```python\ndef macroscopic_xs(micro, N):\n \"\"\"Returns the macroscopic cross section [cm^2] or [barns]\n \n Parameters\n ----------\n micro: double\n microscopic cross section [cm^2] or [barns]\n N: double\n atom density in the medium [atoms/cm^3]\n \"\"\"\n return micro*N\n```\n\n\n```python\ndef NA():\n \"\"\"Returns Avogadro's number \n 6.022x10^23 atoms per mole\n \"\"\"\n return 6.022E23\n\ndef num_dens_from_rho(rho, na, a):\n \"\"\"The atomic number density. \n That is, the concentration of atoms or molecules per unit volume (V)\n \n Parameters\n -----------\n rho : double\n material density (in units like g/cm^3 or kg/m^3) of the sample\n na : double\n Avogadro's number\n a : double\n The atomic or molecular weight of the atom or molecule of interest \n \"\"\"\n return rho*na/a\n```\n\n## Example: \nImagine a beam of neutrons striking a body of water, $H_2O$. Many will be absorbed by the hydrogen in the water, particularly $^1H$. \n\nFind the macroscopic absorption cross section\n\n\n```python\n# Find the macroscpic absorption cross section \n# of the 1H in H2O\nsig_1h = 0.333 # barns\n\n# First, molecular density of water\nrho_h2o = 1 # g/cm^3\na_h2o = 18.0153 # g/mol\nn_h2o = num_dens_from_rho(rho_h2o, NA(), a_h2o) # molecules water / cm^3\nn_h2o_barn = n_h2o/10**(24) # 10^24 molecules water / cm^3\nprint('n_h2o [1/cm^3] = ', n_h2o)\nprint('n_h2o [10^(24)/cm^3] = ', n_h2o_barn)\n\n# Now, there are two Hydrogens in each molecule of water, so:\nmacroscopic_h1 = macroscopic_xs(sig_1h, 2*n_h2o_barn)\nprint('absorption in water from 1H = ', macroscopic_h1)\n```\n\n n_h2o [1/cm^3] = 3.342714248444378e+22\n n_h2o [10^(24)/cm^3] = 0.033427142484443784\n absorption in water from 1H = 0.02226247689463956\n\n\n### Mixtures\nIn a medium that is a mixture of isotopes (e.g. $H_2O$), we can calculate the total macroscopic cross section based on individual microscopic cross sections and number densities for each component of the mixture. We may need to include information about relative isotopic abundances (f).\n\nFor the same problem as above (neutrons striking a body of water) we can calculate the absorption by *all* isotopes in the $H_2O$.\n\n\n\\begin{align}\n\\mu^{H_2O} \\equiv \\Sigma^{H_2O} &= N^1\\sigma_a^1 + N^2\\sigma_a^2 + N^{16}\\sigma_a^{16}\n+ N^{17}\\sigma_a^{17} + N^{18}\\sigma_a^{18}\\\\\n&= f^1N^H\\sigma_a^1 + f^2N^H\\sigma_a^2 + f^{16}N^O\\sigma_a^{16} + f^{17}N^O\\sigma_a^{17} + f^{18}N^O\\sigma_a^{18}\n\\end{align}\n\nSuperscripts 1, 2, 16, 17, and 18 indicate isotopes $^1H$, $^2H$, $^{16}O$,$^{17}O$, and $^{18}O$. \n\n\\begin{align}\nN^H = 2N^{H_2O}\\\\\nN^{O} = N^{H_2O}\\\\\nN^{H_2O} = \\frac{\\rho^{H_2O}N_a}{A^{H_2O}}\n\\end{align}\n\nThus:\n\\begin{align}\n\\mu^{H_2O} \\equiv \\Sigma^{H_2O} &= N^{H_2O}\\left[2f^1\\sigma_a^1 + 2f^2\\sigma_a^2 + f^{16}\\sigma_a^{16} + f^{17}\\sigma_a^{17} + f^{18}\\sigma_a^{18}\\right]\n\\end{align}\n\n\n\n```python\n# We need a lot of data\n\n# Abundances\nf_1 = 0.99985\nf_2 = 0.00015\nf_16 = 0.99756\nf_17 = 0.00039\nf_18 = 0.00205\n\n# Then, microscopic absorption cross sections\nsig_1 = 0.333\nsig_2 = 0.000506\nsig_16 = 0.000190\nsig_17 = 0.239\nsig_18 = 0.000160\n\nmacroscopic_h2o = n_h2o_barn*(2*f_1*sig_1 \n + 2*f_2*sig_2\n + f_16*sig_16\n + f_17*sig_17 \n + f_18*sig_18) \nprint('absorption in water from all isos = ', macroscopic_h2o,\"\\n\",\n 'while absorption in water from 1H = ', macroscopic_h1,\"\\n\",\n 'Thus, absorption in water is mostly from 1H.')\n```\n\n absorption in water from all isos = 0.02226860496564809 \n while absorption in water from 1H = 0.02226247689463956 \n Thus, absorption in water is mostly from 1H.\n\n\n### Reaction Rates\n\n- The microscopic cross section is just the likelihood of the event per unit area. \n- The macroscopic cross section is just the likelihood of the event per unit area of a certain density of target isotopes.\n- The reaction rate is the macroscopic cross section times the flux of incident neutrons.\n\n\\begin{align}\nR_{i,j}(\\vec{r}) &= N_j(\\vec{r})\\int dE \\phi(\\vec{r},E)\\sigma_{i,j}(E)\\\\\nR_{i,j}(\\vec{r}) &= \\mbox{reactions of type i involving isotope j } [reactions/cm^3s]\\\\\nN_j(\\vec{r}) &= \\mbox{number of nuclei participating in the reactions } [\\#/cm^3]\\\\\nE &= \\mbox{energy} [MeV]\\\\\n\\phi(\\vec{r},E)&= \\mbox{flux of neutrons with energy E at position i } [\\#/cm^2s]\\\\\n\\sigma_{i,j}(E)&= \\mbox{cross section } [cm^2]\\\\\n\\end{align}\n\n\nThis can be written more simply as $R_x = \\Sigma_x \\phi$. \n\nUsing flux notation, the density of ith type of neutron interaction with isotope j, per unit time is:\n\n\n\\begin{align}\nR_{i,j}(\\vec{r}) = \\Sigma_{i,j}\\phi(\\vec{r})\n\\end{align}\n\n## Flux density from Point Source\nFinding $\\phi(\\vec{r}0$ generally requires *particle transport calculations.*\n\nHowever, in some simple practical situations, the flux density can be approximated by the flux density of uncollided source particles.\n\n### Point Source in Vacuum\n\nConsider a source of particles:\n\n- it emits $S_p$ particles per unit time\n- all particles have energy E\n- and they are emitted radially outward into an infinite vacuum\n- isotropically (equally in all directions)\n- from a single point in space\n\n### Think-pair share: \n\n- How many interactions occur?\n\n\n### At a radius r: \nBecause the source is isotropic, each unit area on an imaginary spherical shell of radius $r$ has the same number of particles crossing it. Thus:\n\n\\begin{align}\n\\phi^o(r) &= \\mbox{uncollided flux at radius r in any direction}\\\\\n&= \\frac{S_p}{4\\pi r^2}\n\\end{align}\n\n\n```python\ndef phi_o_r(r, s):\n \"\"\"Returns the uncolided flux at radius r\n due to an isotropic point source in a vacuum\n \n Parameters\n -----------\n r : double\n radius away from the point [length]\n s : double\n point source strength [particles/time]\n \"\"\"\n return s/(4*math.pi*pow(r,2))\n```\n\n\n```python\ns=200\nplt.clear()\nplt.plot(range(1,10), [phi_o_r(r, s) for r in range(1,10)])\nplt.show\n```\n\nThe plot above, this $1/r^2$ reduction in flux and reaction rate, is called **geometric attenuation**\n\n### Think-pair-share\n\nWhat other phrase do you think we use for attenuation in a medium? \n\n## Point Source in an Attenuating Medium\nSo, the unollided flux is \n\\begin{align}\n\\phi^o(r) &= \\frac{S_p}{4\\pi r^2}\n\\end{align}\n\n### A small volume\n\nAt a distance r, we place a homogeneous mass with a volume $\\Delta V_d$. The interaction rate $R_d$ in the mass is: \n\n\\begin{align}\n&R^o(r)=\\mu_d(E)\\Delta V_d\\frac{S_p}{4\\pi r^2}\\\\\n\\mbox{where}&\\\\\n&\\mu_d(E)=\\mbox{linear interaction coefficient in the volume}\n\\end{align}\n\n### An inifinite volume\n\nFrom this, we can imagine the point source embedded in an infinite medium of this material. A detector is at distance r in the volume:\n\n\\begin{align}\n&\\phi^o(r) = \\frac{S_p}{4\\pi r^2}e^{-\\mu r}\\\\\n\\mbox{where}&\\\\\n&e^{-\\mu r}=\\mbox{material attenuation} \\\\\n&\\frac{S_p}{4\\pi r^2}=\\mbox{geometric attenuation}\n\\end{align}\n\n### A slab shield\n\nImagine a slab shield, thickness t, at a distance r, between the point source and a detector.\n\n\\begin{align}\n&\\phi^o(r) = \\frac{S_p}{4\\pi r^2}e^{-\\mu t}\\\\\n\\mbox{where}&\\\\\n&t=\\mbox{thickness of the slab}\n\\end{align}\n\nIf it were made of a series of materials $i$, with coefficients $\\mu_i$, and thicknesses $t_i$:\n\n\\begin{align}\n&\\phi^o(r) = \\frac{S_p}{4\\pi r^2}e^{\\sum_i -\\mu_i t_i}\\\\\n\\mbox{where}&\\\\\n&\\mu_i=\\mbox{linear interaction coefficient of ith slab}\\\\\n&t_i=\\mbox{thickness of ith slab}\n\\end{align}\n\n### Heterogeneous Medium\n\nAn arbitrary heterogeneous medium can be described as having an interaction coefficient $\\mu(\\vec{r})$ at any point $\\vec{r}$ in the medium, a funciton of position in the medium.\n\n\\begin{align}\n&\\phi^o(r) = \\frac{S_p}{4\\pi r^2}e^{\\left[-\\int_0^r \\mu(s) ds\\right]}\\\\\n\\end{align}\n\n# Announcements\n* If you had trouble tagging pages based on problems for HW06, this should be fixed by the end of class. If you already submitted, please edit your submission to tag problems appropriately. \n* There will be a HW assigned next Friday. It will be entirely review material based on things that were difficult on previous assignments and the exam. \n* The quiz and HW are posted. The quiz is still due on Monday. \n\n## Polyenergetic Point Source\n\n- Previous examples assume a **monoenergetic** point source (particles of a single energy, E). \n- But, a single source can emit particles at several discrete energies, or even a continuum of energies.\n\nQuestion: From last lecture, what do we expect of fission neutrons? \n\nLet's define some variables:\n\n\\begin{align}\nf_i &= \\mbox{fraction of the source emitted with energy }E_i\\\\\nE_i &= \\mbox{discrete energy of }f_iS_p\\mbox{ particles}\\\\\nS_p &= \\mbox{still the number of particles emitted from the point source}\n\\end{align}\n\nThe total interaction rate caused by uncollided particles streaming through a small volume mass at distance r from the source is the following, **for some set of i discrete energies**.\n\n\\begin{align}\nR^o(r)=\\sum_i\\frac{S_p f_i\\mu_d(E_i) \\Delta V_d}{4\\pi r^2}e^{\\left[-\\int_0^r \\mu(s,E_i) ds\\right]}\\\\\n\\end{align}\n\nIf the source emits a continuum of energies, it's best to define the fraction $f_i$ as a differential probability:\n\n\\begin{align}\nN(E)dE\\mbox{ the probability that a source particle is emitted with energy in dE about E}\n\\end{align}\n\n\nWith this definition, the sum over discrete energies becomes an integral.\n\n\\begin{align}\nR^o(r)=\\int_o^\\infty \\left[\\frac{S_p N(E)\\mu_d(E) \\Delta V_d}{4\\pi r^2}e^{\\left[-\\int_0^r \\mu(s,E) ds\\right]}\\right]dE\\\\\n\\end{align}\n\nPlease note, you may see many nuclear texts list the dE first in the integral... don't be bamboozled. This is equivalent to the above:\n\n\\begin{align}\nR^o(r)=\\int_o^\\infty dE\\frac{S_p N(E)\\mu_d(E) \\Delta V_d}{4\\pi r^2}e^{\\left[-\\int_0^r \\mu(s,E) ds\\right]}\n\\end{align}\n\n\n### Example 7.4 from your book (Shultis & Faw)\n\nA point source with an activity of 500 Ci emits 2-MeV photons with a frequency of 70% per decay. \n\n\\begin{align}\nS_p = 500 Ci\\\\\nf_2 = 0.7\\\\\n\\end{align}\n\nWhat is the flux density of 2-MeV photons 1 meter from the source? \n\n\n\n```python\ns_p = 500 # Ci\nf_2 = 0.7 # fraction emitted at 2MeV\nmu = 1.0/187.0 # mean free path of 2MeV photon in air is 187m\n\n# first, convert S_p is in number of particles per decay (Bq)\nbq_to_ci = 3.7e10 # Bq/Ci\ns_p = s_p*bq_to_ci \n\n# Now, find uncollided flux of 2MeV photons at 1 m\nr = 1.0 #m\ns = s_p*f_2 # just want 2MeV photons\nphi = phi_o_r(r, s)\nprint(\"Uncollided flux is : \", phi)\n\n# Uh oh, we forgot the material attenuation!\nphi = phi_o_r(r, s)*math.exp(-mu*r)\nprint(\"Flux after material attenuation is : \", phi)\n```\n\n Uncollided flux is : 1030528256520.0223\n Flux after material attenuation is : 1025032118881.2917\n\n\n### Think Pair Share\n\nWhat are the units of $\\phi^o$, above?\n\n\n# Photon Interactions\n\n**Recall:** \n \n\\begin{align}\nc &= \\mbox{speed of light}\\\\ \n &=2.9979\\times10^8\\left[\\frac{m}{s}\\right]\\\\\nE &= \\mbox{photon energy}\\\\\n &=h\\nu\\\\\n &=\\frac{hc}{\\lambda}\\\\\nh &= \\mbox{Planck's constant}\\\\\n &= 6.62608\\times10^{−34} [J\\cdot s] \\\\\n\\nu &=\\mbox{photon frequency}\\\\\n\\lambda &= \\mbox{photon wavelength}\n\\end{align}\n\n**Nota bene:**\n- **10eV - 20MeV** photons are important in radiation sheilding\n- At **10eV - 20MeV**, only photoelectric effect, pair production, and Compton Scattering are significant\n\n\nFigure from: \"Radiation Interactions with Tissue.\" Radiology Key. Jan 8 2016. \n\n\n\nFigure from: Cullen, D. E. 1994. \"Photon and Electron Interaction Databases and Their Use in Medical Applications.\" UCRL-JC--117419. Lawrence Livermore National Lab. http://inis.iaea.org/Search/search.aspx?orig_q=RN:26035330. \n\n\n\n## Klein Nishina\n\nThe total Compton cross section, per atom with Z electrons, based on the free-electron approximation, is given by the well-known Klein-Nishina formula [Evans 1955]:\n\n\\begin{align}\n\\sigma_c(E) =\\pi Zr_e^2\\lambda\\left[(-2\\lambda - 2\\lambda^2)\\ln{\\left(1+\\frac{2}{\\lambda}\\right)} + \\frac{2(1+9\\lambda + 8\\lambda^2 + 2\\lambda^3)}{(\\lambda + 2)^2}\\right]\n\\end{align}\n\nHere $\\lambda \\equiv \\frac{m_ec^2}{E}$, a dimensionless quantity, and $r_e$ is the classical electron radius. The value of $r_e$ is given by:\n\n\\begin{align}\nr_e &\\equiv \\frac{e^2}{4\\pi\\epsilon_om_ec^2}\\\\\n&= 2.8179\\times10^{-13}cm\n\\end{align}\n\n\n### Think pair share:\nConceptually, in the above equation:\n\n- what is $r_e$?\n- what is $e$?\n- what is $\\epsilon_o$?\n- what is $m_ec^2$?\n\n\n\n### Total Photon Cross Section\nVarious types of incoherent scattering, including Compton, are actually present in that intermediate energy range. It is occaisionally important to correct for all types of incoherent scattering, but it can typically be assumed to be primarily Compton scattering. \n\nFor photons, then $\\mu$ becomes:\n\n\\begin{align} \n\\mu(E)&\\equiv N\\left[\\sigma_{ph}(E) + \\sigma_{inc}(E) + \\sigma_{pp}(E)\\right]\\\\\n &\\simeq N\\left[\\sigma_{ph}(E) + \\sigma_{c}(E) + \\sigma_{pp}(E)\\right]\\\\\n N &= \\mbox{atom density}\\\\\n &= \\frac{\\rho N_a}{A} \n\\end{align}\n\nIt is common to denote this as the total mass interaction coefficient:\n\n\\begin{align}\n\\frac{\\mu}{\\rho} &= \\frac{N_a}{A}\\left[\\sigma_{ph}(E) + \\sigma_{c}(E) + \\sigma_{pp}(E)\\right]\\\\\n&= \\frac{N_a}{A}\\left[\\frac{\\mu_{ph}(E)}{\\rho} + \\frac{\\mu_{c}(E)}{\\rho} + \\frac{\\mu_{pp}(E)}{\\rho}\\right]\n\\end{align}\n\n## Neutron Interactions\n\nPhotons tend to interact with electrons in a target atom. **Neutrons tend to interact with the nucleus.**\n\nNeutron cross sections:\n\n- Vary rapidly with the incident neutron energy,\n- Vary erratically from one element to another \n- Even vary dramatically between isotopes of the same element.\n\nThere are lots of sources of neutron cross sections. The best place to start is the Brookhaven National Laboratory National Nuclear Data Center [https://www.nndc.bnl.gov/](https://www.nndc.bnl.gov/).\n\nYour book has a clever table (7.1) listing some of the data needed for high and low energy interaction calculations. These include:\n\n- Elastic scattering cross sections \n- Angular distribution of elastically scattered neutrons \n- Inelastic scattering cross sections \n- Angular distribution of inelastically scattered neutrons \n- Gamma-photon yields from inelastic neutron scattering \n- Resonance absorption cross sections \n- Thermal-averaged absorption cross sections \n- Yield of neutron-capture gamma photons\n- Fission cross sections and associated gamma-photon and neutron yields\n\n\n# Total cross sections\n\n**For light nuclei** ($A<25$) and $E<1keV$, the cross section typically varies as:\n\n\\begin{align}\n\\sigma_t = \\sigma_1 + \\frac{\\sigma_2}{\\sqrt{E}}\n\\mbox{where}&\\\\\n\\sigma_1 \\mbox{ and }\\sigma_2 \\mbox{ are constants}& \\\\\n\\sigma_1&=\\mbox{elastic scattering}\\\\\n\\frac{\\sigma_2}{\\sqrt{E}}&=\\mbox{radiative capture}\\\\\n\\end{align}\n\n**For solids** at energies less than about 0.01 eV, Bragg cutoffs apply. These are energies below which no coherent scattering is possible from the material's crystalline planes.\n\n\n**For heavy nuclei**, the total cross section has a $\\frac{1}{\\sqrt{E}}$ behavior with low energy, narrow resonances and high energy broad resonances:\n\n\\begin{align}\n\\sigma_t \\propto \\frac{1}{\\sqrt{E}}\n\\end{align}\n\n### Recall fission cross sections :\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "b756c38254ca06ba0f261d2f6bd59d241adba531", "size": 171619, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "10.06.2-rad_interactions/00-rad-int-matter.ipynb", "max_stars_repo_name": "munkm/npre247", "max_stars_repo_head_hexsha": "5683fa3176e946622a31e3b207484e7ec74f8421", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 3, "max_stars_repo_stars_event_min_datetime": "2022-01-31T17:44:02.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-15T19:54:50.000Z", "max_issues_repo_path": "10.06.2-rad_interactions/00-rad-int-matter.ipynb", "max_issues_repo_name": "munkm/npre247", "max_issues_repo_head_hexsha": "5683fa3176e946622a31e3b207484e7ec74f8421", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 17, "max_issues_repo_issues_event_min_datetime": "2022-01-28T20:32:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-31T17:43:54.000Z", "max_forks_repo_path": "10.06.2-rad_interactions/00-rad-int-matter.ipynb", "max_forks_repo_name": "munkm/npre247", "max_forks_repo_head_hexsha": "5683fa3176e946622a31e3b207484e7ec74f8421", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2022-01-24T16:47:56.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-21T04:09:25.000Z", "avg_line_length": 183.9431939979, "max_line_length": 68899, "alphanum_fraction": 0.883579324, "converted": true, "num_tokens": 6697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47657965106367595, "lm_q2_score": 0.2146914140875998, "lm_q1q2_score": 0.10231755921223548}}
{"text": "```python\n%matplotlib inline\nimport numpy as np\nimport pandas as pd\nimport scipy.stats\nimport matplotlib.pyplot as plt\n\nfrom matplotlib import animation\nfrom matplotlib import rcParams\nrcParams['figure.dpi'] = 120\nfrom IPython.display import HTML\nfrom IPython.display import YouTubeVideo\nfrom functools import partial\nYouTubeVideo_formato = partial(YouTubeVideo, modestbranding=1, disablekb=0,\n width=640, height=360, autoplay=0, rel=0, showinfo=0)\n```\n\n# Estadística inferencial\n\nLa inferencia busca\n\n> Extraer **conclusiones** a partir de **hechos u observaciones** a través de un **método o premisa**\n\nEn el caso particular de la **inferencia estadística** podemos realizar las siguientes asociaciones\n\n- Hechos: Datos\n- Premisa: Modelo probabilístico\n- Conclusión: Una cantidad no observada que es interesante\n\nY lo que buscamos es\n\n> Cuantificar la incerteza de la conclusión dado los datos y el modelo \n\nLa inferencia estadística puede dividirse en los siguientes tres niveles\n\n1. Ajustar un modelo a nuestros datos\n1. Verificar que el modelo sea confiable\n1. Responder una pregunta usando el modelo\n\nEn esta lección estudiaremos las herramientas más utilizadas asociadas a cada uno de estos niveles\n\n1. **Estimador de máxima verosimilitud**\n1. **Bondad de ajuste** e **Intervalos de confianza**\n1. **Test de hipótesis**\n\n## Ajuste de modelos: Estimación de máxima verosimilitud\n\nEn este nivel de inferencia se busca **ajustar** un modelo teórico sobre nuestros datos. En esta lección nos enfocaremos en **modelos de tipo parámetrico**. Un modelo parámetrico es aquel donde **se explicita una distribución de probabilidad**. \n\nRecordemos que una distribución tiene **parámetros**. Por ejemplo la distribución Gaussiana (univariada) se describe por su media $\\mu$ y su varianza $\\sigma^2$. Luego ajustar una distribución Gaussiana corresponde a encontrar el valor de $\\mu$ y $\\sigma$ que hace que el modelo se parezca lo más posible a la distribución empírica de los datos.\n\nA continuación veremos los pasos necesarios para ajustar una distribución a nuestros datos\n\n### ¿Qué distribución ajustar?\n\nAntes de ajustar debemos realizar un supuesto sobre la distribución para nuestro modelo. En general podemos ajustar cualquier distribución pero un mal supuesto podría invalidar nuestra inferencia\n\nPodemos usar las herramientas de **estadística descriptiva** para estudiar nuestros datos y tomar esta decisión de manera informada\n\nEn el siguiente ejemplo, un histograma de los datos revela que un modelo gaussiano no es una buena decisión \n\n\n\n¿Por qué? La distribución empírica es claramente asimétrica, su cola derecha es más pesada que su cola izquierda. La distribución Gaussiana es simétrica por lo tanto no es apropiada en este caso ¿Qué distribución podría ser más apropiada?\n\n\n\n### ¿Cómo ajustar mi modelo? Estimación de máxima verosimilitud\n\nA continuación describiremos un procedimiento para ajustar modelos paramétricos llamado *maximum likelihood estimation* (MLE)\n\nSea un conjunto de datos $\\{x_1, x_2, \\ldots, x_N\\}$\n\n**Supuesto 1** Los datos siguen el modelo $f(x;\\theta)$ donde $f(\\cdot)$ es una distribución y $\\theta$ son sus parámetros\n\n$$\nf(x_1, x_2, \\ldots, x_N |\\theta)\n$$\n\n**Supuesto 2** Las observaciones son independientes e idénticamente distribuidas (iid)\n\n- Si dos variables son independientes se cumple que $P(x, y) = P(x)P(y)$\n- Si son además idénticamente distribuidas entonces tienen **la misma distribución y parámetros**\n\nUsando esto podemos escribir\n\n$$\n\\begin{align}\nf(x_1, x_2, \\ldots, x_N |\\theta) &= f(x_1|\\theta) f(x_2|\\theta) \\ldots f(x_N|\\theta) \\nonumber \\\\\n& = \\prod_{i=1}^N f(x_i|\\theta) \\nonumber \\\\\n& = \\mathcal{L}(\\theta)\n\\end{align}\n$$\n\ndonde $\\mathcal{L}(\\theta)$ se conoce como la verosimilitud o probabilidad inversa de $\\theta$ \n\nSi consideramos que los datos son fijos podemos buscar el valor de $\\theta$ de máxima verosimilitud\n\n$$\n\\begin{align}\n\\hat \\theta &= \\text{arg} \\max_\\theta \\mathcal{L}(\\theta) \\nonumber \\\\\n&= \\text{arg} \\max_\\theta \\log \\mathcal{L}(\\theta) \\nonumber \\\\\n&= \\text{arg} \\max_\\theta \\sum_{i=1}^N \\log f(x_i|\\theta) \n\\end{align}\n$$\n\nEl segundo paso es valido por que el máximo de $g(x)$ y $\\log(g(x))$ es el mismo. El logaritmo es monoticamente creciente. Además aplicar el logaritmo es muy conveniente ya que convierte la multiplicatoria en una sumatoria. \n\nAhora sólo falta encontrar el máximo. Podemos hacerlo\n\n- Analíticamente, derivando con respecto a $\\theta$ e igualando a cero\n- Usando técnicas de optimización iterativas como gradiente descedente\n\n**Ejemplo:** La pesa defectuosa\n\n\n\nSu profesor quiere medir su peso pero sospecha que su pesa está defectuosa. Para comprobarlo mide su peso $N$ veces obteniendo un conjunto de observaciones $\\{x_i\\}$. ¿Es posible obtener un estimador del peso real $\\hat x$ a partir de estas observaciones?\n\nModelaremos las observaciones como\n\n$$\nx_i = \\hat x + \\varepsilon_i\n$$\n\ndonde $\\varepsilon_i$ corresponde al ruido o error del instrumento y asumiremos que $\\varepsilon_i \\sim \\mathcal{N}(0, \\sigma_\\varepsilon^2)$, es decir que el ruido es **independiente** y **Gaussiano** con media cero y **varianza** $\\sigma_\\varepsilon^2$ **conocida**\n\nEntonces la distribución de $x_i$ es\n\n$$\nf(x_i|\\hat x) = \\mathcal{N}(\\hat x, \\sigma_\\varepsilon^2)\n$$\n\nPara encontrar $\\hat x$, primero escribimos el logaritmo de la **verosimilitud**\n\n$$\n\\begin{align}\n\\log \\mathcal{L}(\\hat x) &= \\sum_{i=1}^N \\log f(x_i|\\hat x) \\nonumber \\\\\n&= \\sum_{i=1}^N \\log \\frac{1}{\\sqrt{2\\pi\\sigma_\\varepsilon^2}} \\exp \\left ( - \\frac{1}{2\\sigma_\\varepsilon^2} (x_i - \\hat x)^2 \\right) \\nonumber \\\\\n&= -\\frac{N}{2}\\log(2\\pi\\sigma_\\varepsilon^2) - \\frac{1}{2\\sigma_\\varepsilon^2} \\sum_{i=1}^N (x_i - \\hat x)^2 \\nonumber\n\\end{align}\n$$\n\nLuego debemos resolver\n\n$$\n\\begin{align}\n\\hat \\theta &= \\text{arg} \\max_\\theta \\log \\mathcal{L}(\\theta) \\nonumber \\\\\n&= \\text{arg} \\max_\\theta - \\frac{1}{2\\sigma_\\varepsilon^2} \\sum_{i=1}^N (x_i - \\hat x)^2\n\\end{align}\n$$\n\ndonde podemos ignorar el primer término de la verosimilitud ya que no depende de $\\theta$. Para encontrar el máximo derivamos la expresión anterior e igualamos a cero \n\n$$\n-\\frac{1}{2\\sigma_\\varepsilon^2} \\sum_{i=1}^N 2(x_i - \\hat x ) = 0.\n$$\n\nFinalmente si despejamos llegamos a que\n\n$$\n\\hat x = \\frac{1}{N} \\sum_{i=1}^N x_i,\n$$\n\nque se conoce como el estimador de máxima verosimilitud **para la media de una Gaussiana**\n\nRecordemos que podemos comprobar que es un máximo utilizando la segunda derivada\n\n### Estimación MLE con `scipy`\n\nComo vimos en la lección anterior el módulo [`scipy.stats`](https://docs.scipy.org/doc/scipy/reference/stats.html) provee de un gran número de distribuciones teóricas organizadas como \n\n- continuas de una variable\n- discretas de una variable\n- multivariadas\n\nLas distribuciones comparten muchos de sus métodos, a continuación revisaremos los más importantes. A modo de ejemplo consideremos la distribución Gaussiana (Normal)\n\n```python\nfrom scipy.stats import norm\ndist = norm() # Esto crea una Gaussiana con media 0 y desviación estándar (std) 1\ndist = norm(loc=2, scale=2) # Esto crea una Gaussiana con media 2 y std 2\n```\n\n**Crear una muestra aleatoria con `rvs`**\n\nLuego de crear un objeto distribución podemos obtener una muestra aleatoria usando el método el atributo `rvs` \n\n```python\ndist = norm(loc=2, scale=2)\ndist.rvs(size=10, # Cantidad de números aleatorios generados\n random_state=None #Semilla aleatoria\n )\n```\n\nEsto retorna un arreglo de 10 números generados aleatoriamente a partir de `dist`\n\n**Evaluar la función de densidad de probabilidad** \n\nLa función de densidad de la Gaussiana es\n\n$$\nf(x; \\mu, \\sigma^2) = \\frac{1}{\\sqrt{2\\pi \\sigma^2}} \\exp \\left( -\\frac{1}{2\\sigma^2} (x-\\mu)^2 \\right) \n$$\n\nLa densidad de un objeto distribución continuo puede obtenerse con el método `pdf` el cual es función de `x`\n\n\n```python\ndist = norm(loc=2, scale=2)\np = dist.pdf(x # Un ndrray que representa x en la ecuación superior\n )\nplt.plot(x, p) # Luego podemos graficar la fdp\n```\n\nDe forma equivalente, si deseamos la función de densidad acumulada usamos el método `cdf`\n\nPara objetos distribución discretos debemos usar el atributo `pmf` \n\n\n**Ajustar los parámetros con MLE**\n\nPara hacer el ajuste se usa el método `fit`\n\n```python \nparams = norm.fit(data # Un ndarray con los datos\n ) \n```\n\nEn el caso de la Gaussiana el vector `params` tiene dos componentes `loc` y `scale`. La cantidad de parámetros depende de la distribución que estemos ajustando. También es importante notar que para ajustar se usa `norm` (clase abstracta) y no `norm()` (instancia)\n\nUna vez que tenemos los parámetros ajustados podemos usarlos con\n\n```python\ndist = norm(loc=params[0], scale=params[1])\n```\n\nPara distribuciones que tienen más de dos parámetros podemos usar\n\n```python\ndist = norm(*params[:-2], loc=params[-2], scale=params[-1])\n```\n\n### Ejercicio\n\nObserve la siguiente distribución y reflexione ¿Qué características resaltan de la misma? ¿Qué distribución sería apropiado ajustar en este caso?\n\n\n```python\ndf = pd.read_csv('../data/cancer.csv', index_col=0)\ndf = df[[\"diagnosis\", \"radius1\", \"texture1\"]]\nx = df[\"radius1\"].values\nfig, ax = plt.subplots(figsize=(5, 3), tight_layout=True)\nax.hist(x, bins=20, density=True)\nax.set_xlabel('Radio del nucleo');\n```\n\n- Seleccione una distribución de `scipy.stats` ajustela a los datos\n- Grafique la pdf teórica sobre el histograma\n\n\n```python\n\n```\n\n## Verificación de modelos: Tests de bondad de ajuste\n\nUna vez que hemos ajustado un modelo es buena práctica verificar que tan confiable es este ajuste. Las herramientas más típicas para medir que tan bien se ajusta nuestra distribución teórica son\n\n- el [test de Akaike](https://en.wikipedia.org/wiki/Akaike_information_criterion)\n- los [gráficos cuantil-cuantil](https://es.wikipedia.org/wiki/Gr%C3%A1fico_Q-Q) (QQ plot)\n- el test no-paramétrico de Kolmogorov-Smirnov (KS)\n\nA continuación revisaremos el test de KS para bondad de ajuste\n\n**El test de Kolmogorov-Smirnov**\n\nEs un test no-paramétrico que compara una muestra de datos estandarizados (distribución empírica) con una distribución de densidad acumulada (CDF) teórica. Este test busca refutar la siguiente hipótesis\n\n> **Hipótesis nula:** Las distribuciones son idénticas\n\nPara aplicar el test primero debemos **estandarizar** los datos. Estandarizar se refiere a la transformación\n\n$$\nz = \\frac{x - \\mu_x}{\\sigma_x}\n$$\n\nes decir los datos estándarizados tienen media cero y desviación estándar uno\n\nEsto puede hacerse fácilmente con NumPy usando\n\n```python\nz = (x - np.mean(x))/np.std(x)\n```\n\n### Test de KS con `scipy`\n\nPodemos realizar el test de KS con la función [`scipy.stats.kstest`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.kstest.html) donde\n\n```python\nscipy.stats.kstest(rvs, # Una muestra de observaciones estandarizadas\n cdf, # Una distribución acumulada teórica, por ejemplo scipy.stats.norm.cdf\n ...\n )\n```\n\nEsta función retorna el valor del estadístico de KS y su *p-value* asociado. Mientras más cerca de cero sea el estadístico de KS mejor es el ajuste. \n\nMás adelante haremos un repaso de tests de hipótesis en detalle. De momento recordemos que si el *p-value* es menor que una confianza $\\alpha=0.05$ entonces rechazamos la hipótesis nula con confianza $1-\\alpha = 0.95$ o $95\\%$\n\n\n### Ejercicio \n\nConsidere la muestra de datos anterior\n- Seleccione un conjunto de distribuciones teóricas \n- Encuentra la que tiene mejor ajuste usando `kstest`\n\n\n```python\n\n```\n\n## Responder preguntas con nuestro modelo: Test de hipótesis\n\nSe aplica un tratamiento nuevo a una muestra de la población \n\n- ¿Es el tratamiento efectivo?\n- ¿Existe una diferencia entre los que tomaron el tratamiento y los que no?\n\nEl test de hipótesis es un procedimiento estadístico para comprobar si el resultado de un experimento es significativo en la población\n\nPara esto formulamos dos escenarios cada uno con una hipótesis asociada\n\n- Hipótesis nula ($H_0$): Por ejemplo\n - \"El experimento no produjo diferencia\"\n - \"El experimento no tuvo efecto\"\n - \"Las observaciones son producto del azar\"\n- Hipótesis alternativa ($H_A$): Usualmente el complemento de $H_0$\n\n> El test de hipótesis se diseña para medir que tan fuerte es la evidencia **en contra** de la hipótesis nula\n\n### Algoritmo general de un test de hipótesis\n\nEl siguiente es el algoritmo general de un test de hipótesis paramétrico\n\n1. Definimos $H_0$ y $H_A$\n1. Definimos un estadístico $T$\n1. Asumimos una distribución para $T$ dado que $H_0$ es cierto\n1. Seleccionamos un nivel de significancia $\\alpha$ \n1. Calculamos el $T$ para nuestros datos $T_{data}$\n1. Calculamos el **p-value**\n - Si nuestro test es de una cola:\n - Superior: $p = P(T>T_{data})$\n - Inferior: $p = P(TT_{data}) + P(T Rechazamos la hipótesis nula con confianza (1-$\\alpha$)\n\n`De lo contrario`\n \n> No hay suficiente evidencia para rechazar la hipótesis nula\n\nEl valor de $\\alpha$ nos permite controlar el **[Error tipo I](https://es.wikipedia.org/wiki/Errores_de_tipo_I_y_de_tipo_II)**, es decir el error que cometemos si rechazamos $H_0$ cuando en realidad era cierta (falso positivo)\n\nTipicamente se usa $\\alpha=0.05$ o $\\alpha=0.01$ \n\n\n**Errores de interpretación comunes**\n\nMuchas veces se asume que el p-value es la probabilidad de que $H_0$ sea cierta dado nuestras observaciones\n\n$$\np = P(H_0 | T> T_{data})\n$$\n\nEsto es un **grave error**. Formálmente el **p-value** es la probabilidad de observar un valor de $T$ más extremo que el observado, es decir \n\n$$\np = P(T> T_{data} | H_0) \n$$\n\nOtro error común es creer que no ser capaz de rechazar $H_0$ es lo mismo que aceptar $H_0$\n\nNo tener suficiente evidencia para rechazar no es lo mismo que aceptar\n\n### Un primer test de hipótesis: El t-test de una muestra \n\nSea un conjunto de $N$ observaciones iid $X = {x_1, x_2, \\ldots, x_N}$ con media muestral $\\bar x = \\sum_{i=1}^N x_i$ \n\nEl t-test de una muestra es un test de hipótesis que busca verificar si $\\bar x$ es significativamente distinta de la **media poblacional** $\\mu$, en el caso de que **no conocemos la varianza poblacional** $\\sigma^2$\n\nLas hipótesis son\n\n- $H_0:$ $\\bar x = \\mu$\n- $H_A:$ $\\bar x \\neq \\mu$ (dos colas)\n\nEl estadístico de prueba es \n\n$$\nt = \\frac{\\bar x - \\mu}{\\hat \\sigma /\\sqrt{N-1}}\n$$\n\ndonde $\\hat \\sigma = \\sqrt{ \\frac{1}{N} \\sum_{i=1}^N (x_i - \\bar x)^2}$ es la desviación estándar muestral (sesgada)\n\nSi asumimos que $\\bar x$ se distribuye $\\mathcal{N}(\\mu, \\frac{\\sigma^2}{N})$ entonces\n$t$ se distribuye [t-student](https://en.wikipedia.org/wiki/Student%27s_t-distribution) con $N-1$ grados de libertad\n\n- Para muestras iid y $N$ grande el supuesto se cumple por teorema central del límite\n- Si $N$ es pequeño debemos verificar la normalidad de los datos\n\n\n### Aplicación de t-test para probar que la regresión es significativa\n\nEn un modelo de regresión lineal donde tenemos $N$ ejemplos\n\n$$\ny_i = x_i \\theta_1 + \\theta_0, ~ i=1, 2, \\ldots, N\n$$\n\nPodemos probar que la correlación entre $x$ es $y$ es significativa con un test sobre $\\theta_1$\n\nPor ejemplo podemos plantear las siguientes hipótesis\n\n- $H_0:$ La pendiente es nula $\\theta_1= 0$ \n- $H_A:$ La pendiente no es nula: $\\theta_1\\neq 0$ (dos colas)\n\nY asumiremos que $\\theta_1$ es normal pero que desconocemos su varianza. Bajo este supuesto se puede formular el siguiente estadístico de prueba \n\n$$\nt = \\frac{(\\theta_1-\\theta^*) }{\\text{SE}_{\\theta_1}/\\sqrt{N-2}} = \\frac{ r\\sqrt{N-2}}{\\sqrt{1-r^2}},\n$$\n\ndonde $r$ es el coeficiente de correlación de Pearson (detalles más adelante) y la última expresión se obtiene reemplazando $\\theta^*=0$ y $\\text{SE}_{\\theta_1} = \\sqrt{ \\frac{\\frac{1}{N} \\sum_i (y_i - \\hat y_i)^2}{\\text{Var}(x)}}$. \n\nEl estadístico tiene distribución t-student con dos grados de libertad (modelo de dos parámetros) \n\n\n## Ejercicio formativo: Regresión lineal \n\nEn lecciones anteriores estudiamos el modelo de regresión lineal el cual nos permite estudiar si existe correlación entre variables continuas. También vimos como ajustar los parámetros del modelo usando el método de mínimos cuadrados. En este ejercicio formativo veremos como verificar si el modelo de regresión ajustado es correcto\n\nLuego de revisar este ejercicio usted habrá aprendido\n\n- La interpretación probabilística de la regresión lineal y la relación entre mínimos cuadrados ordinarios y la estimación por máxima verosimilitud\n- El estadístico $r$ para medir la fuerza de la correlación entre dos variables\n- Un test de hipótesis para verificar que la correlación encontrada es estadística significativa\n\nUsaremos el siguiente dataset de consumo de helados. Referencia: [A handbook of small datasets](https://www.routledge.com/A-Handbook-of-Small-Data-Sets/Hand-Daly-McConway-Lunn-Ostrowski/p/book/9780367449667), estudio realizado en los años 50\n\n\n```python\ndf = pd.read_csv('../data/helados.csv', header=0, index_col=0)\ndf.columns = ['consumo', 'ingreso', 'precio', 'temperatura']\ndisplay(df.head())\n```\n\nEl dataset tiene la temperatura promedio del día (grados Fahrenheit), el precio promedio de los helados comprados (dolares), el ingreso promedio familiar semanal de las personas que compraron helado (dolares) y el consumo ([pintas](https://en.wikipedia.org/wiki/Pint) per capita).\n\nA continuación se muestra un gráfico de dispersión del consumo en función de las demás variables. ¿Cree usted que existe correlación en este caso?\n\n\n```python\nfig, ax = plt.subplots(1, 3, figsize=(8, 3), tight_layout=True, sharey=True)\nfor i, col in enumerate(df.columns[1:]):\n ax[i].scatter(df[col], df[\"consumo\"], s=10)\n ax[i].set_xlabel(col)\nax[0].set_ylabel(df.columns[0]);\n```\n\n### Interpretación probabilística y MLE de la regresión lineal\n\nSea $y$ el consumo y $x$ la temperatura.\n\nAsumiremos errores gaussianos iid\n\n$$\ny_i = \\hat y_i + \\epsilon_i, \\epsilon_i \\sim \\mathcal{N}(0, \\sigma^2),\n$$\n\ny un modelo lineal de **dos parámetros** (linea recta)\n\n$$\n\\hat y_i = \\theta_0 + \\theta_1 x_i\n$$\n\nBajo estos supuestos el estimador de máxima verosimilitud es \n\n$$\n\\begin{align}\n\\hat \\theta &= \\text{arg}\\max_\\theta \\log \\mathcal{L}(\\theta) \\nonumber \\\\\n&=\\text{arg}\\max_\\theta - \\frac{1}{2\\sigma^2} \\sum_{i=1}^N (y_i - \\theta_0 - \\theta_1 x_i)^2 \\nonumber\n\\end{align}\n$$\n\nEs decir que el estimador de máxima verosimilitud es equivalente al de mínimos cuadrados ordanrios $\\hat \\theta= (X^T X)^{-1} X^T y$ que vimos anteriormente\n\n**Importante:** Cuando utilizamos la solución de mínimos cuadrados estamos asumiendo implicitamente que las observaciones son iid y que la verosimilitud es Gaussiana\n\n\nDerivando con respecto a los parámetros e igualado a cero tenemos que\n\n$$\n\\begin{align}\n\\sum_i y_i - N\\theta_0 - \\theta_1 \\sum_i x_i &= 0 \\nonumber \\\\\n\\sum_i y_i x_i - \\theta_0 \\sum_i x_i - \\theta_1 \\sum_i x_i^2 &= 0 \\nonumber\n\\end{align}\n$$\n\nFinalmente podemos despejar\n\n$$\n\\begin{align}\n\\theta_0 &= \\bar y - \\theta_1 \\bar x \\nonumber \\\\\n\\theta_1 &= \\frac{\\sum_i x_i y_i - N \\bar x \\bar y}{\\sum_i x_i^2 - M \\bar x^2} \\nonumber \\\\\n&= \\frac{ \\sum_i (y_i - \\bar y)(x_i - \\bar x)}{\\sum_i (x_i - \\bar x)^2} = \\frac{\\text{COV}(x, y)}{\\text{Var}(x)}\n\\end{align}\n$$\n\nde donde reconocemos las expresiones para la covarianza entre $x$ e $y$ y la varianza de $x$\n\n\n### Coeficiente de correlación de Pearson\n\nLa fuerza de la correlación se suele medir usando\n\n$$\nr^2 = 1 - \\frac{\\sum_i ( y_i - \\hat y_i)^2}{\\sum_i ( y_i - \\bar y)^2} = 1 - \\frac{\\frac{1}{M} \\sum_i (y_i - \\hat y_i)^2}{\\text{Var}(y)} = \\frac{\\text{COV}^2(x, y)}{\\text{Var}(x) \\text{Var}(y)}\n$$\n\ndonde $r = \\frac{\\text{COV}(x, y)}{\\sqrt{\\text{Var}(x) \\text{Var}(y)}} \\in [-1, 1]$ se conoce como [coeficiente de correlación de Pearson](https://en.wikipedia.org/wiki/Pearson_correlation_coefficient)\n\ndonde\n\n- si $r=1$ existe una correlación lineal perfecta\n- si $r=-1$ existe una anticorrelación lineal perfecta\n- si $r=0$ no hay correlación lineal entre las variables\n\nEn general un $r>0.5$ se considera una correlación importante\n\n**Calculando $r$ con y los parámetros de la regresión lineal**\n\nPodemos usar el atributo de dataframe\n\n```python\ndf.corr()\n```\n\nQue retorna la matriz de correlaciones lineales\n\n\n```python\ndf.corr()\n```\n\nSi queremos también el valor de los parámetros podemos usar la función de scipy \n\n```python\nscipy.stats.linregress(x, # Variable independiente unidimensional\n y # Variable dependiente unidimensional\n )\n```\n\nEsta función retorna una tupla con\n\n- Valor de la pendiente: $\\theta_1$\n- Valor de la intercepta: $\\theta_0$\n- Coeficiente de correlación $r$\n- p-value\n- Error estándar del ajuste\n\n\n```python\nfig, ax = plt.subplots(1, 3, figsize=(8, 3), tight_layout=True, sharey=True)\nax[0].set_ylabel(df.columns[0]);\n\n\nfor i, col in enumerate(df.columns[1:]):\n res = scipy.stats.linregress(df[col], df[\"consumo\"])\n x_plot = np.linspace(np.amin(df[col]), np. amax(df[col]), num=100)\n ax[i].scatter(df[col], df[\"consumo\"], label='datos', s=10) \n ax[i].plot(x_plot, res.slope*x_plot + res.intercept, lw=2, c='r', label='modelo');\n ax[i].set_xlabel(col)\n ax[i].set_title(f\"$r$: {res.rvalue:0.5f}\")\n ax[i].legend()\n```\n\nEs decir que visualmente parece existir\n\n- una correlación positiva alta entre consumo y temperatura\n- una correlación negativa moderada entre consumo y precio\n- una correlación cercana a cero entre consumo e ingreso\n\n### Test de hipótesis y conclusiones\n\nLa función `linregress` implementa el t-test sobre $\\theta_1$ que vimos anteriormente. Usemos estos resultados para verificar si las correlaciones son estadísticamente significativas\n\n\n```python\nalpha = 0.05\n\nfor i, col in enumerate(df.columns[1:]):\n res = scipy.stats.linregress(df[col], df[\"consumo\"])\n print(f\"{col}: \\t p-value:{res.pvalue:0.4f} \\t ¿Menor que {alpha}?: {res.pvalue < alpha}\") \n```\n\nComo complemento visualizemos \n\n- las distribuciones bajo la hipótesis nula: linea azul\n- los límites dados por $\\alpha$: linea punteada negra\n- El valor del observado para cada una de las variables: linea roja \n\n\n```python\nfig, ax = plt.subplots(1, 3, figsize=(8, 2), tight_layout=True, sharey=True)\nax[0].set_ylabel(df.columns[0]);\n\nN = df.shape[0]\nt = np.linspace(-7, 7, num=1000)\ndist = scipy.stats.t(loc=0, scale=1, df=N-2) # dos grados de libertad\n\n\nfor i, col in enumerate(df.columns[1:]):\n res = scipy.stats.linregress(df[col], df[\"consumo\"])\n t_data = res.rvalue*np.sqrt(N-2)/np.sqrt(1.-res.rvalue**2)\n ax[i].plot(t, dist.pdf(t))\n ax[i].plot([dist.ppf(alpha/2)]*2, [0, np.amax(dist.pdf(t))], 'k--')\n ax[i].plot([dist.ppf(1-alpha/2)]*2, [0, np.amax(dist.pdf(t))], 'k--')\n ax[i].plot([t_data]*2, [0, np.amax(dist.pdf(t))], 'r-')\n ax[i].set_xlabel(col) \n```\n\n**Conclusión**\n\nBasado en los p-values y considerando $\\alpha=0.05$\n\n¿Qué podemos decir de las correlaciones con el consumo de helados?\n\n> Rechazamos la hipótesis nula de que no existe correlación entre temperatura y consumo con un 95% de confianza\n\nPara las variables ingreso y precio no existe suficiente evidencia para rechazar $H_0$\n\n### Reflexión final\n\nEn el ejercicio anterior usamos t-test para una regresión lineal entre dos variables ¿Qué prueba puedo usar si quiero hacer regresión lineal multivariada? \n\n> Se puede usar [ANOVA](https://pythonfordatascience.org/anova-python/)\n\n¿Qué pasa si...\n\n- mis datos tienen una relación que no es lineal? \n- $\\theta_1$ no es Gaussiano/normal? \n- si el ruido no es Gaussiano? \n- si el ruido es Gaussiano pero su varianza cambia en el tiempo? \n\n> En estos casos no se cumplen los supuestos del modelo o del test, por ende el resultado no es confiable\n\nSi mis supuestos no se cumplen con ninguna prueba parámetrica, la opión es utilizar pruebas no-paramétricas\n\n## Prueba no-paramétrica: *Bootstrap*\n\nPodemos estimar la incerteza de un estimador de forma no-paramétrica usando **muestreo tipo *bootstrap***\n\nEsto consiste en tomar nuestro conjunto de datos de tamaño $N$ y crear $T$ nuevos conjuntos que \"se le parezcan\". Luego se calcula el valor del estimador que estamos buscando en los $T$ conjuntos. Con esto obtenemos una distribución para el estimador como muestra el siguiente diagrama\n\n\n\n\n\nPara crear los subconjuntos podríamos suponer independencia y utilizar **muestreo con reemplazo**. Esto consiste en tomar $N$ muestras al azar permitiendo repeticiones, como muestra el siguiente diagrama\n\n\n\nSi no es posible suponer indepdencia se puede realizar bootstrap basado en residuos y bootstrap dependiente. Puedes consultar más detalles sobre [*bootstrap*](https://www.stat.cmu.edu/~cshalizi/402/lectures/08-bootstrap/lecture-08.pdf) [aquí](http://homepage.divms.uiowa.edu/~rdecook/stat3200/notes/bootstrap_4pp.pdf) y [acá](https://www.sagepub.com/sites/default/files/upm-binaries/21122_Chapter_21.pdf). A continuación nos enfocaremos en el clásico muestreo con reemplazo y como implementarlo en Python\n\n### Implementación con Numpy y Scipy\n\nLa función `numpy.random.choice` permite remuestrear un conjunto de datos\n\nPor ejemplo para la regresión lineal debemos remuestrar las parejas/tuplas $(x_i, y_i)$\n\nLuego calculamos y guardamos los parámetros del modelo para cada remuestreo. En este ejemplo haremos $1000$ repeticiones del conjunto de datos\n\n\n```python\ndf = pd.read_csv('../data/helados.csv', header=0, index_col=0)\ndf.columns = ['consumo', 'ingreso', 'precio', 'temperatura']\n\nx, y = df[\"temperatura\"].values, df[\"consumo\"].values\nparams = scipy.stats.linregress(x, y)\n\ndef muestreo_con_reemplazo(x, y):\n N = len(x)\n idx = np.random.choice(N, size=N, replace=True)\n return x[idx], y[idx]\n\ndef boostrap_linregress(x, y, T=100):\n # Parámetros: t0, t1 y r\n params = np.zeros(shape=(T, 3)) \n for t in range(T):\n res = scipy.stats.linregress(*muestreo_con_reemplazo(x, y))\n params[t, :] = [res.intercept, res.slope, res.rvalue]\n return params\n\nboostrap_params = boostrap_linregress(x, y, T=1000)\n```\n\n### Intervalos de confianza empíricos\n\nVeamos la distribución empírica de $r$ obtenida usando bootstrap\n\nEn la figura de abajo tenemos\n\n- Histograma azul: Distribución bootstrap de $r$\n- Linea roja: $r$ de los datos\n- Lineas punteadas negras: Intervalo de confianza empírico al 95%\n\n\n\n```python\nr_bootstrap = boostrap_params[:, 2]\n\nfig, ax = plt.subplots(figsize=(4, 3), tight_layout=True)\nhist_val, hist_lim, _ = ax.hist(r_bootstrap, bins=20, density=True)\n\nax.plot([params.rvalue]*2, [0, np.max(hist_val)], 'r-', lw=2)\nIC = np.percentile(r_bootstrap, [2.5, 97.5])\nax.plot([IC[0]]*2, [0, np.max(hist_val)], 'k--', lw=2)\nax.plot([IC[1]]*2, [0, np.max(hist_val)], 'k--', lw=2)\n\nprint(f\"Intervalo de confianza al 95% de r: {IC}\")\n```\n\nDe la figura podemos notar que el 95% de la distribución empírica esta sobre $r=0.5$\n\nTambién podemos notar que la distribución empírica de $r$ no es simétrica, por lo que aplicar un t-test parámetrico sobre $r$ no hubiera sido correcto \n\n### Visualizando la incerteza del modelo\n\nUsando la distribución empírica de los parámetros $\\theta_0$ y $\\theta_1$ podemos visualizar la incerteza de nuestro modelo de regresión lineal\n\nEn la figura de abajo tenemos\n- Puntos azules: Datos\n- Linea roja: Modelo de regresión lineal en los datos\n- Sombra rojo claro: $\\pm 2$ desviaciones estándar del modelo en base a la distribución empírica\n\n\n```python\nfig, ax = plt.subplots(figsize=(4, 3), tight_layout=True)\nax.set_ylabel('Consumo')\nax.set_xlabel('Temperatura')\nax.scatter(x, y, zorder=100, s=10, label='datos')\n\ndef model(theta0, theta1, x):\n return x*theta1 + theta0\n\nax.plot(x_plot, model(params.intercept, params.slope, x_plot),\n c='r', lw=2, label='mejor ajuste')\n\ndist_lines = model(boostrap_params[:, 0], boostrap_params[:, 1], x_plot.reshape(-1, 1)).T\nmean_lines, std_lines = np.mean(dist_lines, axis=0), np.std(dist_lines, axis=0)\nax.fill_between(x_plot, \n mean_lines - 2*std_lines,\n mean_lines + 2*std_lines, \n color='r', alpha=0.25, label='incerteza')\nplt.legend();\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "de1f1efcc7aea32ea8544b6481a50af797cb8ba0", "size": 40731, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "clases/unidad2/3_statistics/stats3.ipynb", "max_stars_repo_name": "magister-informatica-uach/INFO147", "max_stars_repo_head_hexsha": "3898eb6f589a22beefb5972a0c911bb9dd098c6d", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 13, "max_stars_repo_stars_event_min_datetime": "2019-04-12T21:10:39.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-12T14:30:09.000Z", "max_issues_repo_path": "clases/unidad2/3_statistics/stats3.ipynb", "max_issues_repo_name": "magister-informatica-uach/INFO147", "max_issues_repo_head_hexsha": "3898eb6f589a22beefb5972a0c911bb9dd098c6d", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "clases/unidad2/3_statistics/stats3.ipynb", "max_forks_repo_name": "magister-informatica-uach/INFO147", "max_forks_repo_head_hexsha": "3898eb6f589a22beefb5972a0c911bb9dd098c6d", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2019-04-12T20:00:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-17T21:48:53.000Z", "avg_line_length": 37.8893023256, "max_line_length": 510, "alphanum_fraction": 0.5913186516, "converted": true, "num_tokens": 8582, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4532618332444287, "lm_q2_score": 0.22541661063147306, "lm_q1q2_score": 0.10217274617856706}}
{"text": "Ctrl + Enter .\n\nSecond, each cell has a type. There are two main types: Markdown (which is for any kind of free text, explanations, formulas, results... you get the idea), and code (which is, well... for code :D).\n\nLet me give you a...\n#### Quick Introduction to Markdown\n##### Text and Paragraphs\nThere are several things that you can do. As you already saw, you can write paragraph text just by typing it. In order to create a new paragraph, just leave a blank line. See how this works below:\n```\nThis is some text.\nThis text is on a new line, but it will continue the same paragraph (so you can make your paragraphs more easily readable by just continuing on a new line, or just go on and on like this one line is ever continuing).\n\nThis text is displayed in a new paragraph.\n\nAnd this is yet another paragraph.\n```\n**Result:**\n\nThis is some text.\nThis text is on a new line, but it will continue the same paragraph (so you can make your paragraphs more easily readable by just continuing on a new line, or just go on and on like this one line is ever continuing).\n\nThis text is displayed in a new paragraph.\n\nAnd this is yet another paragraph.\n\n##### Headings\nThere are six levels of headings. Level one is the highest (largest and most important), and level 6 is the smallest. You can create headings of several types by prefixing the header line with one to six \"#\" symbols (this is called a pound sign if you are ancient, or a sharp sign if you're a musician... or a hashtag if you're too young :D). Have a look:\n```\n# Heading 1\n## Heading 2\n### Heading 3\n#### Heading 4\n##### Heading 5\n###### Heading 6\n```\n\n**Result:**\n\n# Heading 1\n## Heading 2\n### Heading 3\n#### Heading 4\n##### Heading 5\n###### Heading 6\n\nIt is recommended that you have **only one** H1 heading - this should be the header of your notebook (or scientific paper). Below that, you can add your name or just jump to the explanations directly.\n\n##### Emphasis\nYou can create emphasized (stronger) text by using a **bold** or _italic_ font. You can do this in several ways (using asterisks (\\*) or underscores (\\_)). In order to \"escape\" a symbol, prefix it with a backslash (\\). You can also strike through your text in order to signify a correction.\n```\n**bold** __bold__\n*italic* _italic_\n\nThis is \\*\\*not \\*\\* bold.\n\nI ~~didn't make~~ a mistake.\n```\n\n**Result:**\n\n**bold** __bold__\n*italic* _italic_\n\nThis is \\*\\*not\\*\\* bold.\n\nI ~~didn't make~~ a mistake.\n\n##### Lists\nYou can add two types of lists: ordered and unordered. Lists can also be nested inside one another. To do this, press Tab once (it will be converted to 4 spaces).\n\nTo create an ordered list, just type the numbers. Don't worry if your numbers are wrong - Jupyter Notebook will create them properly for you. Well, it's better to have them properly numbered anyway...\n```\n1. This is\n2. A list\n10. With many\n9. Items\n 1. Some of which\n 2. Can\n 3. Be nested\n42. You can also\n * Mix \n * list\n * types\n```\n\n**Result:**\n1. This is\n2. A list\n10. With many\n9. Items\n 1. Some of which\n 2. Can\n 3. Be nested\n42. You can also\n * Mix \n * list\n * types\n \nTo create an unordered list, type an asterisk, plus or minus at the beginning:\n```\n* This is\n* An\n + Unordered\n - list\n```\n\n**Result:**\n* This is\n* An\n + Unordered\n - list\n \n##### Links\nThere are many ways to create links but we mostly use one of them: we present links with some explanatory text. See how it works:\n```\nThis is [a link](http://google.com) to Google.\n```\n\n**Result:**\n\nThis is [a link](http://google.com) to Google.\n\n##### Images\nThey are very similar to links. Just prefix the image with an exclamation mark. The alt(ernative) text will be displayed if the image is not available. Have a look (hover over the image to see the title text):\n```\n Do you know that \"taco cat\" is a palindrome? Thanks to The Oatmeal :)\n```\n\n**Result:**\n\n Do you know that \"taco cat\" is a palindrome? Thanks to The Oatmeal :)\n\nIf you want to resize images or do some more advanced stuff, just use HTML. \n\nDid I mention these cells support HTML, CSS and JavaScript? Now I did.\n\n##### Tables\nThese are a pain because they need to be formatted (somewhat) properly. Here's a good [table generator](http://www.tablesgenerator.com/markdown_tables). Just select File > Paste table data... and provide a tab-separated list of values. It will generate a good-looking ASCII-art table for you.\n```\n| Cell1 | Cell2 | Cell3 |\n|-------|-------|-------|\n| 1.1 | 1.2 | 1.3 |\n| 2.1 | 2.2 | 2.3 |\n| 3.1 | 3.2 | 3.3 |\n```\n\n**Result:**\n\n| Cell1 | Cell2 | Cell3 |\n|-------|-------|-------|\n| 1.1 | 1.2 | 1.3 |\n| 2.1 | 2.2 | 2.3 |\n| 3.1 | 3.2 | 3.3 |\n\n##### Code\nJust use triple backtick symbols. If you provide a language, it will be syntax-highlighted. You can also use inline code with single backticks.\n\n```python\ndef square(x):\n return x ** 2\n```\nThis is `inline` code. No syntax highlighting here.\n \n\n**Result:**\n```python\ndef square(x):\n return x ** 2\n```\nThis is `inline` code. No syntax highlighting here.\n\n**Now it's your turn to have some Markdown fun.** In the next cell, try out some of the commands. You can just throw in some things, or do something more structured (like a small notebook).\n\n##### Code\nJust use triple backtick symbols. If you provide a language, it will be syntax-highlighted. You can also use inline code with single backticks.\n\n```python\ndef square(x):\n return x ** 2\n```\nThis is `inline` code. No syntax highlighting here.\n \n\n**Result:**\n```C#\nprivate double square(x)\n{\n return Math.Pow(x,2);\n}\n```\nThis is `inline C#` code. No syntax highlighting here.\n\n### Problem 2. Formulas and LaTeX\nWriting math formulas has always been hard. But scientists don't like difficulties and prefer standards. So, thanks to Donald Knuth (a very popular computer scientist, who also invented a lot of algorithms), we have a nice typesetting system, called LaTeX (pronounced _lah_-tek). We'll be using it mostly for math formulas, but it has a lot of other things to offer.\n\nThere are two main ways to write formulas. You could enclose them in single `$` signs like this: `$ ax + b $`, which will create an **inline formula**: $ ax + b $. You can also enclose them in double `$` signs `$$ ax + b $$` to produce $$ ax + b $$.\n\nMost commands start with a backslash and accept parameters either in square brackets `[]` or in curly braces `{}`. For example, to make a fraction, you typically would write `$$ \\frac{a}{b} $$`: $$ \\frac{a}{b} $$.\n\n[Here's a resource](http://www.stat.pitt.edu/stoffer/freetex/latex%20basics.pdf) where you can look up the basics of the math syntax. You can also search StackOverflow - there are all sorts of solutions there.\n\nYou're on your own now. Research and recreate all formulas shown in the next cell. Try to make your cell look exactly the same as mine. It's an image, so don't try to cheat by copy/pasting :D.\n\nNote that you **do not** need to understand the formulas, what's written there or what it means. We'll have fun with these later in the course.\n\n\n\n\n$$ x=ax_{1}^{2}+ 2ax_{2}-\\sin120^{\\circ} + ( \\,\\frac{2ab}{y} )\\, $$\n$$ $M = \\left( \\begin{matrix} a&b\\\\ c&d \\\\ x&y \\end{matrix} \\right)$ $$ \n\n\n\n\n### Problem 3. Solving with Python\nLet's first do some symbolic computation. We need to import `sympy` first. \n\n**Should your imports be in a single cell at the top or should they appear as they are used?** There's not a single valid best practice. Most people seem to prefer imports at the top of the file though. **Note: If you write new code in a cell, you have to re-execute it!**\n\nLet's use `sympy` to give us a quick symbolic solution to our equation. First import `sympy` (you can use the second cell in this notebook): \n```python \nimport sympy \n```\n\nNext, create symbols for all variables and parameters. You may prefer to do this in one pass or separately:\n```python \nx = sympy.symbols('x')\na, b, c = sympy.symbols('a b c')\n```\n\nNow solve:\n```python \nsympy.solve(a * x**2 + b * x + c)\n```\n\nHmmmm... we didn't expect that :(. We got an expression for $a$ because the library tried to solve for the first symbol it saw. This is an equation and we have to solve for $x$. We can provide it as a second paramter:\n```python \nsympy.solve(a * x**2 + b * x + c, x)\n```\n\nFinally, if we use `sympy.init_printing()`, we'll get a LaTeX-formatted result instead of a typed one. This is very useful because it produces better-looking formulas.\n\n\n```python\nsympy.init_printing()\n```\n\n\n```python\nsympy.symbols(\"x,y,z\")\n```\n\nHow about a function that takes $a, b, c$ (assume they are real numbers, you don't need to do additional checks on them) and returns the **real** roots of the quadratic equation?\n\nRemember that in order to calculate the roots, we first need to see whether the expression under the square root sign is non-negative.\n\nIf $b^2 - 4ac > 0$, the equation has two real roots: $x_1, x_2$\n\nIf $b^2 - 4ac = 0$, the equation has one real root: $x_1 = x_2$\n\nIf $b^2 - 4ac < 0$, the equation has zero real roots\n\nWrite a function which returns the roots. In the first case, return a list of 2 numbers: `[2, 3]`. In the second case, return a list of only one number: `[2]`. In the third case, return an empty list: `[]`.\n\n\n```python\n\ndef solve_quadratic_equation(a, b, c):\n \"\"\"\n Returns the real solutions of the quadratic equation ax^2 + bx + c = 0\n \"\"\"\n D= b**2 - 4*a*c\n \n if D > 0:\n x1=(-b -math.sqrt(D))/(2*a)\n x2=(-b +math.sqrt(D))/(2*a)\n return [x1,x2]\n elif D==0:\n x=-b /(2*a)\n return [x]\n elif D<0:\n return []\n \n```\n\n\n```python\n# Testing: Execute this cell. The outputs should match the expected outputs. Feel free to write more tests\nprint(solve_quadratic_equation(1, -1, -2)) # [-1.0, 2.0]\nprint(solve_quadratic_equation(1, -8, 16)) # [4.0]\nprint(solve_quadratic_equation(1, 1, 1)) # []\n```\n\n [-1.0, 2.0]\n [4.0]\n []\n\n\n**Bonus:** Last time we saw how to solve a linear equation. Remember that linear equations are just like quadratic equations with $a = 0$. In this case, however, division by 0 will throw an error. Extend your function above to support solving linear equations (in the same way we did it last time).\n\n### Problem 4. Equation of a Line\nLet's go back to our linear equations and systems. There are many ways to define what \"linear\" means, but they all boil down to the same thing.\n\nThe equation $ax + b = 0$ is called *linear* because the function $f(x) = ax+b$ is a linear function. We know that there are several ways to know what one particular function means. One of them is to just write the expression for it, as we did above. Another way is to **plot** it. This is one of the most exciting parts of maths and science - when we have to fiddle around with beautiful plots (although not so beautiful in this case).\n\nThe function produces a straight line and we can see it.\n\nHow do we plot functions in general? Ww know that functions take many (possibly infinitely many) inputs. We can't draw all of them. We could, however, evaluate the function at some points and connect them with tiny straight lines. If the points are too many, we won't notice - the plot will look smooth.\n\nNow, let's take a function, e.g. $y = 2x + 3$ and plot it. For this, we're going to use `numpy` arrays. This is a special type of array which has two characteristics:\n* All elements in it must be of the same type\n* All operations are **broadcast**: if `x = [1, 2, 3, 10]` and we write `2 * x`, we'll get `[2, 4, 6, 20]`. That is, all operations are performed at all indices. This is very powerful, easy to use and saves us A LOT of looping.\n\nThere's one more thing: it's blazingly fast because all computations are done in C, instead of Python.\n\nFirst let's import `numpy`. Since the name is a bit long, a common convention is to give it an **alias**:\n```python\nimport numpy as np\n```\n\nImport that at the top cell and don't forget to re-run it.\n\nNext, let's create a range of values, e.g. $[-3, 5]$. There are two ways to do this. `np.arange(start, stop, step)` will give us evenly spaced numbers with a given step, while `np.linspace(start, stop, num)` will give us `num` samples. You see, one uses a fixed step, the other uses a number of points to return. When plotting functions, we usually use the latter. Let's generate, say, 1000 points (we know a straight line only needs two but we're generalizing the concept of plotting here :)).\n```python\nx = np.linspace(-3, 5, 1000)\n```\nNow, let's generate our function variable\n```python\ny = 2 * x + 3\n```\n\nWe can print the values if we like but we're more interested in plotting them. To do this, first let's import a plotting library. `matplotlib` is the most commnly used one and we usually give it an alias as well.\n```python\nimport matplotlib.pyplot as plt\n```\n\nNow, let's plot the values. To do this, we just call the `plot()` function. Notice that the top-most part of this notebook contains a \"magic string\": `%matplotlib inline`. This hints Jupyter to display all plots inside the notebook. However, it's a good practice to call `show()` after our plot is ready.\n```python\nplt.plot(x, y)\nplt.show()\n```\n\n\n```python\nx = np.linspace(-6, 6, 1000)\ny = 2 * x + 3\n\nax = plt.gca()\nax.spines['top'].set_color('none')\nax.spines['bottom'].set_position('zero')\nax.spines['left'].set_position('zero')\nax.spines['right'].set_color('none')\nplt.plot(x,y,'-r', label=r'$y = {2x}+3$')\nplt.xlabel('x')\nplt.ylabel('y')\nplt.title('Exponential Curve')\nplt.legend(loc='upper left')\nplt.show()\n```\n\nIt doesn't look too bad bit we can do much better. See how the axes don't look like they should? Let's move them to zeto. This can be done using the \"spines\" of the plot (i.e. the borders).\n\nAll `matplotlib` figures can have many plots (subfigures) inside them. That's why when performing an operation, we have to specify a target figure. There is a default one and we can get it by using `plt.gca()`. We usually call it `ax` for \"axis\".\nLet's save it in a variable (in order to prevent multiple calculations and to make code prettier). Let's now move the bottom and left spines to the origin $(0, 0)$ and hide the top and right one.\n```python\nax = plt.gca()\nax.spines[\"bottom\"].set_position(\"zero\")\nax.spines[\"left\"].set_position(\"zero\")\nax.spines[\"top\"].set_visible(False)\nax.spines[\"right\"].set_visible(False)\n```\n\n**Note:** All plot manipulations HAVE TO be done before calling `show()`. It's up to you whether they should be before or after the function you're plotting.\n\nThis should look better now. We can, of course, do much better (e.g. remove the double 0 at the origin and replace it with a single one), but this is left as an exercise for the reader :).\n\n\n```python\n# Copy and edit your code here\n```\n\n### * Problem 5. Linearizing Functions\nWhy is the line equation so useful? The main reason is because it's so easy to work with. Scientists actually try their best to linearize functions, that is, to make linear functions from non-linear ones. There are several ways of doing this. One of them involves derivatives and we'll talk about it later in the course. \n\nA commonly used method for linearizing functions is through algebraic transformations. Try to linearize \n$$ y = ae^{bx} $$\n\nHint: The inverse operation of $e^{x}$ is $\\ln(x)$. Start by taking $\\ln$ of both sides and see what you can do. Your goal is to transform the function into another, linear function. You can look up more hints on the Internet :).\n\n\n```python\na = 5\nb = 0.9\nc = 1\nx = np.linspace(0, 10, 256, endpoint = True)\ny = (a * np.exp(-b*x))\n\nplt.plot(x, y, '-r', label=r'$y = 5e^{2x}$')\n\naxes = plt.gca()\naxes.set_xlim([x.min(), x.max()])\naxes.set_ylim([y.min(), y.max()])\n\nplt.xlabel('x')\nplt.ylabel('y')\nplt.title('Exponential Curve')\nplt.legend(loc='upper left')\n\nplt.show()\n```\n\n### * Problem 6. Generalizing the Plotting Function\nLet's now use the power of Python to generalize the code we created to plot. In Python, you can pass functions as parameters to other functions. We'll utilize this to pass the math function that we're going to plot.\n\nNote: We can also pass *lambda expressions* (anonymous functions) like this: \n```python\nlambda x: x + 2```\nThis is a shorter way to write\n```python\ndef some_anonymous_function(x):\n return x + 2\n```\n\nWe'll also need a range of x values. We may also provide other optional parameters which will help set up our plot. These may include titles, legends, colors, fonts, etc. Let's stick to the basics now.\n\nWrite a Python function which takes another function, x range and number of points, and plots the function graph by evaluating it at every point.\n\n**BIG hint:** If you want to use not only `numpy` functions for `f` but any one function, a very useful (and easy) thing to do, is to vectorize the function `f` (e.g. to allow it to be used with `numpy` broadcasting):\n```python\nf_vectorized = np.vectorize(f)\ny = f_vectorized(x)\n```\n\n\n```python\ndef f(x):\n return 2.718281828459045**(1+x)\n\ndef tailor(x, eps):\n x = 1+x\n sum = 1+x\n term = x;\n n = 2;\n while term*term > eps*eps:\n term *= x/n\n n += 1\n sum += term\n return sum\n\na=3.0\nb=4.0\nkrok=(b-a)/10\n\nwhile a<=b: \n print(round(a,2), end=' ')\n print(round(f(a),5),end=' ')\n print(round(tailor(a,1e-6),5))\n ax = plt.gca()\n ax.spines['top'].set_color('none')\n ax.spines['bottom'].set_position('zero')\n ax.spines['left'].set_position('zero')\n ax.spines['right'].set_color('none')\n plt.plot(m,'-r', label=r'$y = {2x}+3$')\n plt.xlabel('x')\n plt.ylabel('y')\n plt.title('Exponential Curve')\n plt.legend(loc='upper left')\n plt.show()\n a+=krok\n```\n\n\n```python\ndef plot_math_function(f, min_x, max_x, num_points):\n # Write your code here\n pass\n```\n\n\n```python\nplot_math_function(lambda x: 2 * x + 3, -3, 5, 1000)\nplot_math_function(lambda x: -x + 8, -1, 10, 1000)\nplot_math_function(lambda x: x**2 - x - 2, -3, 4, 1000)\nplot_math_function(lambda x: np.sin(x), -np.pi, np.pi, 1000)\nplot_math_function(lambda x: np.sin(x) / x, -4 * np.pi, 4 * np.pi, 1000)\n```\n\n### * Problem 7. Solving Equations Graphically\nNow that we have a general plotting function, we can use it for more interesting things. Sometimes we don't need to know what the exact solution is, just to see where it lies. We can do this by plotting the two functions around the \"=\" sign ans seeing where they intersect. Take, for example, the equation $2x + 3 = 0$. The two functions are $f(x) = 2x + 3$ and $g(x) = 0$. Since they should be equal, the point of their intersection is the solution of the given equation. We don't need to bother marking the point of intersection right now, just showing the functions.\n\nTo do this, we'll need to improve our plotting function yet once. This time we'll need to take multiple functions and plot them all on the same graph. Note that we still need to provide the $[x_{min}; x_{max}]$ range and it's going to be the same for all functions.\n\n```python\nvectorized_fs = [np.vectorize(f) for f in functions]\nys = [vectorized_f(x) for vectorized_f in vectorized_fs]\n```\n\n\n```python\ndef plot_math_functions(functions, min_x, max_x, num_points):\n # Write your code here\n pass\n```\n\n\n```python\nplot_math_functions([lambda x: 2 * x + 3, lambda x: 0], -3, 5, 1000)\nplot_math_functions([lambda x: 3 * x**2 - 2 * x + 5, lambda x: 3 * x + 7], -2, 3, 1000)\n```\n\nThis is also a way to plot the solutions of systems of equation, like the one we solved last time. Let's actually try it.\n\n\n```python\nplot_math_functions([lambda x: (-4 * x + 7) / 3, lambda x: (-3 * x + 8) / 5, lambda x: (-x - 1) / -2], -1, 4, 1000)\n```\n\n### Problem 8. Trigonometric Functions\nWe already saw the graph of the function $y = \\sin(x)$. But, how do we define the trigonometric functions once again? Let's quickly review that.\n\n\n\nThe two basic trigonometric functions are defined as the ratio of two sides:\n$$ \\sin(x) = \\frac{\\text{opposite}}{\\text{hypotenuse}} $$\n$$ \\cos(x) = \\frac{\\text{adjacent}}{\\text{hypotenuse}} $$\n\nAnd also:\n$$ \\tan(x) = \\frac{\\text{opposite}}{\\text{adjacent}} = \\frac{\\sin(x)}{\\cos(x)} $$\n$$ \\cot(x) = \\frac{\\text{adjacent}}{\\text{opposite}} = \\frac{\\cos(x)}{\\sin(x)} $$\n\nThis is fine, but using this, \"right-triangle\" definition, we're able to calculate the trigonometric functions of angles up to $90^\\circ$. But we can do better. Let's now imagine a circle centered at the origin of the coordinate system, with radius $r = 1$. This is called a \"unit circle\".\n\n\n\nWe can now see exactly the same picture. The $x$-coordinate of the point in the circle corresponds to $\\cos(\\alpha)$ and the $y$-coordinate - to $\\sin(\\alpha)$. What did we get? We're now able to define the trigonometric functions for all degrees up to $360^\\circ$. After that, the same values repeat: these functions are **periodic**: \n$$ \\sin(k.360^\\circ + \\alpha) = \\sin(\\alpha), k = 0, 1, 2, \\dots $$\n$$ \\cos(k.360^\\circ + \\alpha) = \\cos(\\alpha), k = 0, 1, 2, \\dots $$\n\nWe can, of course, use this picture to derive other identities, such as:\n$$ \\sin(90^\\circ + \\alpha) = \\cos(\\alpha) $$\n\nA very important property of the sine and cosine is that they accept values in the range $(-\\infty; \\infty)$ and produce values in the range $[-1; 1]$. The two other functions take values in the range $(-\\infty; \\infty)$ **except when their denominators are zero** and produce values in the same range. \n\n#### Radians\nA degree is a geometric object, $1/360$th of a full circle. This is quite inconvenient when we work with angles. There is another, natural and intrinsic measure of angles. It's called the **radian** and can be written as $\\text{rad}$ or without any designation, so $\\sin(2)$ means \"sine of two radians\".\n\n\nIt's defined as *the central angle of an arc with length equal to the circle's radius* and $1\\text{rad} \\approx 57.296^\\circ$.\n\nWe know that the circle circumference is $C = 2\\pi r$, therefore we can fit exactly $2\\pi$ arcs with length $r$ in $C$. The angle corresponding to this is $360^\\circ$ or $2\\pi\\ \\text{rad}$. Also, $\\pi rad = 180^\\circ$.\n\n(Some people prefer using $\\tau = 2\\pi$ to avoid confusion with always multiplying by 2 or 0.5 but we'll use the standard notation here.)\n\n**NOTE:** All trigonometric functions in `math` and `numpy` accept radians as arguments. In order to convert between radians and degrees, you can use the relations $\\text{[deg]} = 180/\\pi.\\text{[rad]}, \\text{[rad]} = \\pi/180.\\text{[deg]}$. This can be done using `np.deg2rad()` and `np.rad2deg()` respectively.\n\n#### Inverse trigonometric functions\nAll trigonometric functions have their inverses. If you plug in, say $\\pi/4$ in the $\\sin(x)$ function, you get $\\sqrt{2}/2$. The inverse functions (also called, arc-functions) take arguments in the interval $[-1; 1]$ and return the angle that they correspond to. Take arcsine for example:\n$$ \\arcsin(y) = x: sin(y) = x $$\n$$ \\arcsin\\left(\\frac{\\sqrt{2}}{2}\\right) = \\frac{\\pi}{4} $$\n\nPlease note that this is NOT entirely correct. From the relations we found:\n$$\\sin(x) = sin(2k\\pi + x), k = 0, 1, 2, \\dots $$\n\nit follows that $\\arcsin(x)$ has infinitely many values, separated by $2k\\pi$ radians each:\n$$ \\arcsin\\left(\\frac{\\sqrt{2}}{2}\\right) = \\frac{\\pi}{4} + 2k\\pi, k = 0, 1, 2, \\dots $$\n\nIn most cases, however, we're interested in the first value (when $k = 0$). It's called the **principal value**.\n\nNote 1: There are inverse functions for all four basic trigonometric functions: $\\arcsin$, $\\arccos$, $\\arctan$, $\\text{arccot}$. These are sometimes written as $\\sin^{-1}(x)$, $\\cos^{-1}(x)$, etc. These definitions are completely equivalent. \n\nJust notice the difference between $\\sin^{-1}(x) := \\arcsin(x)$ and $\\sin(x^{-1}) = \\sin(1/x)$.\n\n#### Exercise\nUse the plotting function you wrote above to plot the inverse trigonometric functions. Use `numpy` (look up how to use inverse trigonometric functions).\n\n\n```python\n# Write your code here\n```\n\n### ** Problem 9. Perlin Noise\nThis algorithm has many applications in computer graphics and can serve to demonstrate several things... and help us learn about math, algorithms and Python :).\n#### Noise\nNoise is just random values. We can generate noise by just calling a random generator. Note that these are actually called *pseudorandom generators*. We'll talk about this later in this course.\nWe can generate noise in however many dimensions we want. For example, if we want to generate a single dimension, we just pick N random values and call it a day. If we want to generate a 2D noise space, we can take an approach which is similar to what we already did with `np.meshgrid()`.\n\n$$ \\text{noise}(x, y) = N, N \\in [n_{min}, n_{max}] $$\n\nThis function takes two coordinates and returns a single number N between $n_{min}$ and $n_{max}$. (This is what we call a \"scalar field\").\n\nRandom variables are always connected to **distributions**. We'll talk about these a great deal but now let's just say that these define what our noise will look like. In the most basic case, we can have \"uniform noise\" - that is, each point in our little noise space $[n_{min}, n_{max}]$ will have an equal chance (probability) of being selected.\n\n#### Perlin noise\nThere are many more distributions but right now we'll want to have a look at a particular one. **Perlin noise** is a kind of noise which looks smooth. It looks cool, especially if it's colored. The output may be tweaked to look like clouds, fire, etc. 3D Perlin noise is most widely used to generate random terrain.\n\n#### Algorithm\n... Now you're on your own :). Research how the algorithm is implemented (note that this will require that you understand some other basic concepts like vectors and gradients).\n\n#### Your task\n1. Research about the problem. See what articles, papers, Python notebooks, demos, etc. other people have created\n2. Create a new notebook and document your findings. Include any assumptions, models, formulas, etc. that you're using\n3. Implement the algorithm. Try not to copy others' work, rather try to do it on your own using the model you've created\n4. Test and improve the algorithm\n5. (Optional) Create a cool demo :), e.g. using Perlin noise to simulate clouds. You can even do an animation (hint: you'll need gradients not only in space but also in time)\n6. Communicate the results (e.g. in the Softuni forum)\n\nHint: [This](http://flafla2.github.io/2014/08/09/perlinnoise.html) is a very good resource. It can show you both how to organize your notebook (which is important) and how to implement the algorithm.\n", "meta": {"hexsha": "ec1d151b3f2ab3b83a557ca8ac23b5141a4c5468", "size": 81893, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "01.Math_Concept_For_Devs/02. High-School-Maths-Exercise/High-School Maths Exercise.ipynb", "max_stars_repo_name": "vladimirpetukhov/Artifical_Intelligence_Course", "max_stars_repo_head_hexsha": "0dd9a959f5f8b5e413dbddb13d80bb917c124fb5", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-03-27T16:01:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-27T16:01:53.000Z", "max_issues_repo_path": "01.Math_Concept_For_Devs/02. High-School-Maths-Exercise/High-School Maths Exercise.ipynb", "max_issues_repo_name": "vladimirpetukhov/Artifical_Intelligence_Course", "max_issues_repo_head_hexsha": "0dd9a959f5f8b5e413dbddb13d80bb917c124fb5", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "01.Math_Concept_For_Devs/02. High-School-Maths-Exercise/High-School Maths Exercise.ipynb", "max_forks_repo_name": "vladimirpetukhov/Artifical_Intelligence_Course", "max_forks_repo_head_hexsha": "0dd9a959f5f8b5e413dbddb13d80bb917c124fb5", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 91.0934371524, "max_line_length": 13368, "alphanum_fraction": 0.7498565201, "converted": true, "num_tokens": 7460, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.399811640739795, "lm_q2_score": 0.25386100132422423, "lm_q1q2_score": 0.10149658345928537}}
{"text": "```\n# this mounts your Google Drive to the Colab VM.\nfrom google.colab import drive\ndrive.mount('/content/drive', force_remount=True)\n\n# enter the foldername in your Drive where you have saved the unzipped\n# assignment folder, e.g. 'cs231n/assignments/assignment3/'\nFOLDERNAME = 'cs231n/assignments/assignment2/'\nassert FOLDERNAME is not None, \"[!] Enter the foldername.\"\n\n# now that we've mounted your Drive, this ensures that\n# the Python interpreter of the Colab VM can load\n# python files from within it.\nimport sys\nsys.path.append('/content/drive/My Drive/{}'.format(FOLDERNAME))\n\n# this downloads the CIFAR-10 dataset to your Drive\n# if it doesn't already exist.\n%cd drive/My\\ Drive/$FOLDERNAME/cs231n/datasets/\n!bash get_datasets.sh\n%cd /content\n```\n\n Mounted at /content/drive\n /content/drive/My Drive/cs231n/assignments/assignment2/cs231n/datasets\n /content\n\n\n# Batch Normalization\nOne way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \nOne idea along these lines is batch normalization which was proposed by [1] in 2015.\n\nThe idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n\nThe authors of [1] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [1] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n\nIt is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n\n[1] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\nInternal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)\n\n\n```\n# As usual, a bit of setup\nimport time\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom cs231n.classifiers.fc_net import *\nfrom cs231n.data_utils import get_CIFAR10_data\nfrom cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\nfrom cs231n.solver import Solver\n\n%matplotlib inline\nplt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\nplt.rcParams['image.interpolation'] = 'nearest'\nplt.rcParams['image.cmap'] = 'gray'\n\n# for auto-reloading external modules\n# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n%load_ext autoreload\n%autoreload 2\n\ndef rel_error(x, y):\n \"\"\" returns relative error \"\"\"\n return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n\ndef print_mean_std(x,axis=0):\n print(' means: ', x.mean(axis=axis))\n print(' stds: ', x.std(axis=axis))\n print() \n```\n\n =========== You can safely ignore the message below if you are NOT working on ConvolutionalNetworks.ipynb ===========\n \tYou will need to compile a Cython extension for a portion of this assignment.\n \tThe instructions to do this will be given in a section of the notebook below.\n \tThere will be an option for Colab users and another for Jupyter (local) users.\n\n\n\n```\n# Load the (preprocessed) CIFAR10 data.\ndata = get_CIFAR10_data()\nfor k, v in data.items():\n print('%s: ' % k, v.shape)\n```\n\n X_train: (49000, 3, 32, 32)\n y_train: (49000,)\n X_val: (1000, 3, 32, 32)\n y_val: (1000,)\n X_test: (1000, 3, 32, 32)\n y_test: (1000,)\n\n\n## Batch normalization: forward\nIn the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n\nReferencing the paper linked to above in [1] may be helpful!\n\n\n```\n# Check the training-time forward pass by checking means and variances\n# of features both before and after batch normalization \n\n# Simulate the forward pass for a two-layer network\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before batch normalization:')\nprint_mean_std(a,axis=0)\n\ngamma = np.ones((D3,))\nbeta = np.zeros((D3,))\n# Means should be close to zero and stds close to one\nprint('After batch normalization (gamma=1, beta=0)')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n\ngamma = np.asarray([1.0, 2.0, 3.0])\nbeta = np.asarray([11.0, 12.0, 13.0])\n# Now means should be close to beta and stds close to gamma\nprint('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=0)\n```\n\n Before batch normalization:\n means: [ -2.3814598 -13.18038246 1.91780462]\n stds: [27.18502186 34.21455511 37.68611762]\n \n After batch normalization (gamma=1, beta=0)\n means: [5.32907052e-17 7.04991621e-17 1.85962357e-17]\n stds: [0.99999999 1. 1. ]\n \n After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n means: [11. 12. 13.]\n stds: [0.99999999 1.99999999 2.99999999]\n \n\n\n\n```\n# Check the test-time forward pass by running the training-time\n# forward pass many times to warm up the running averages, and then\n# checking the means and variances of activations after a test-time\n# forward pass.\n\nnp.random.seed(231)\nN, D1, D2, D3 = 200, 50, 60, 3\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\n\nbn_param = {'mode': 'train'}\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n\nfor t in range(50):\n X = np.random.randn(N, D1)\n a = np.maximum(0, X.dot(W1)).dot(W2)\n batchnorm_forward(a, gamma, beta, bn_param)\n\nbn_param['mode'] = 'test'\nX = np.random.randn(N, D1)\na = np.maximum(0, X.dot(W1)).dot(W2)\na_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n\n# Means should be close to zero and stds close to one, but will be\n# noisier than training-time forward passes.\nprint('After batch normalization (test-time):')\nprint_mean_std(a_norm,axis=0)\n```\n\n After batch normalization (test-time):\n means: [-0.03927354 -0.04349152 -0.10452688]\n stds: [1.01531428 1.01238373 0.97819988]\n \n\n\n## Batch normalization: backward\nNow implement the backward pass for batch normalization in the function `batchnorm_backward`.\n\nTo derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n\nOnce you have finished, run the following to numerically check your backward pass.\n\n\n```\n# Gradient check batchnorm backward pass\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nfx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\nfg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\nfb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = batchnorm_forward(x, gamma, beta, bn_param)\ndx, dgamma, dbeta = batchnorm_backward(dout, cache)\n#You should expect to see relative errors between 1e-13 and 1e-8\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n dx error: 1.702926400705332e-09\n dgamma error: 7.420414216247087e-13\n dbeta error: 2.8795057655839487e-12\n\n\n## Batch normalization: alternative backward\nIn class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n\nSurprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too! \n\nIn the forward pass, given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n\nwe first calculate the mean $\\mu$ and variance $v$.\nWith $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma$ and normalized data $Y$.\nThe equations and graph illustration below describe the computation ($y_i$ is the i-th element of the vector $Y$).\n\n\\begin{align}\n& \\mu=\\frac{1}{N}\\sum_{k=1}^N x_k & v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2 \\\\\n& \\sigma=\\sqrt{v+\\epsilon} & y_i=\\frac{x_i-\\mu}{\\sigma}\n\\end{align}\n\n\n\nThe meat of our problem during backpropagation is to compute $\\frac{\\partial L}{\\partial X}$, given the upstream gradient we receive, $\\frac{\\partial L}{\\partial Y}.$ To do this, recall the chain rule in calculus gives us $\\frac{\\partial L}{\\partial X} = \\frac{\\partial L}{\\partial Y} \\cdot \\frac{\\partial Y}{\\partial X}$.\n\nThe unknown/hart part is $\\frac{\\partial Y}{\\partial X}$. We can find this by first deriving step-by-step our local gradients at \n$\\frac{\\partial v}{\\partial X}$, $\\frac{\\partial \\mu}{\\partial X}$,\n$\\frac{\\partial \\sigma}{\\partial v}$, \n$\\frac{\\partial Y}{\\partial \\sigma}$, and $\\frac{\\partial Y}{\\partial \\mu}$,\nand then use the chain rule to compose these gradients (which appear in the form of vectors!) appropriately to compute $\\frac{\\partial Y}{\\partial X}$.\n\nIf it's challenging to directly reason about the gradients over $X$ and $Y$ which require matrix multiplication, try reasoning about the gradients in terms of individual elements $x_i$ and $y_i$ first: in that case, you will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. \n\nYou should make sure each of the intermediary gradient derivations are all as simplified as possible, for ease of implementation. \n\nAfter doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster.\n\n\n```\nnp.random.seed(231)\nN, D = 100, 500\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nbn_param = {'mode': 'train'}\nout, cache = batchnorm_forward(x, gamma, beta, bn_param)\n\nt1 = time.time()\ndx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\nt2 = time.time()\ndx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\nt3 = time.time()\n\nprint('dx difference: ', rel_error(dx1, dx2))\nprint('dgamma difference: ', rel_error(dgamma1, dgamma2))\nprint('dbeta difference: ', rel_error(dbeta1, dbeta2))\nprint('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))\n```\n\n dx difference: 9.431854837645182e-13\n dgamma difference: 0.0\n dbeta difference: 0.0\n speedup: 1.79x\n\n\n## Fully Connected Nets with Batch Normalization\nNow that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n\nConcretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n\nHINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`.\n\n\n```\nnp.random.seed(231)\nN, D, H1, H2, C = 2, 15, 20, 30, 10\nX = np.random.randn(N, D)\ny = np.random.randint(C, size=(N,))\n\n# You should expect losses between 1e-4~1e-10 for W, \n# losses between 1e-08~1e-10 for b,\n# and losses between 1e-08~1e-09 for beta and gammas.\nfor reg in [0, 3.14]:\n print('Running check with reg = ', reg)\n model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n reg=reg, weight_scale=5e-2, dtype=np.float64,\n normalization='batchnorm')\n\n loss, grads = model.loss(X, y)\n print('Initial loss: ', loss)\n\n for name in sorted(grads):\n f = lambda _: model.loss(X, y)[0]\n grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n if reg == 0: print()\n```\n\n Running check with reg = 0\n Initial loss: 2.2611955101340957\n W1 relative error: 1.10e-04\n W2 relative error: 2.85e-06\n W3 relative error: 4.05e-10\n b1 relative error: 4.44e-08\n b2 relative error: 2.22e-08\n b3 relative error: 1.01e-10\n beta1 relative error: 7.33e-09\n beta2 relative error: 1.89e-09\n gamma1 relative error: 6.96e-09\n gamma2 relative error: 1.96e-09\n \n Running check with reg = 3.14\n Initial loss: 6.996533220108303\n W1 relative error: 1.98e-06\n W2 relative error: 2.28e-06\n W3 relative error: 1.11e-08\n b1 relative error: 5.55e-09\n b2 relative error: 2.22e-08\n b3 relative error: 1.42e-10\n beta1 relative error: 6.65e-09\n beta2 relative error: 3.48e-09\n gamma1 relative error: 8.80e-09\n gamma2 relative error: 5.28e-09\n\n\n# Batchnorm for deep networks\nRun the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization.\n\n\n```\nnp.random.seed(231)\n# Try training a very deep net with batchnorm\nhidden_dims = [100, 100, 100, 100, 100]\n\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nweight_scale = 2e-2\nbn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\nmodel = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\nprint('Solver with batch norm:')\nbn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True,print_every=20)\nbn_solver.train()\n\nprint('\\nSolver without batch norm:')\nsolver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=True, print_every=20)\nsolver.train()\n```\n\n Solver with batch norm:\n (Iteration 1 / 200) loss: 2.340974\n (Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n (Epoch 1 / 10) train acc: 0.315000; val_acc: 0.266000\n (Iteration 21 / 200) loss: 2.039365\n (Epoch 2 / 10) train acc: 0.384000; val_acc: 0.279000\n (Iteration 41 / 200) loss: 2.041102\n (Epoch 3 / 10) train acc: 0.494000; val_acc: 0.309000\n (Iteration 61 / 200) loss: 1.753902\n (Epoch 4 / 10) train acc: 0.531000; val_acc: 0.307000\n (Iteration 81 / 200) loss: 1.246584\n (Epoch 5 / 10) train acc: 0.573000; val_acc: 0.314000\n (Iteration 101 / 200) loss: 1.320590\n (Epoch 6 / 10) train acc: 0.632000; val_acc: 0.338000\n (Iteration 121 / 200) loss: 1.159472\n (Epoch 7 / 10) train acc: 0.686000; val_acc: 0.325000\n (Iteration 141 / 200) loss: 1.156477\n (Epoch 8 / 10) train acc: 0.767000; val_acc: 0.336000\n (Iteration 161 / 200) loss: 0.630541\n (Epoch 9 / 10) train acc: 0.802000; val_acc: 0.345000\n (Iteration 181 / 200) loss: 0.862820\n (Epoch 10 / 10) train acc: 0.788000; val_acc: 0.332000\n \n Solver without batch norm:\n (Iteration 1 / 200) loss: 2.302332\n (Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n (Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n (Iteration 21 / 200) loss: 2.041970\n (Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n (Iteration 41 / 200) loss: 1.900473\n (Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n (Iteration 61 / 200) loss: 1.713156\n (Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n (Iteration 81 / 200) loss: 1.662209\n (Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n (Iteration 101 / 200) loss: 1.696062\n (Epoch 6 / 10) train acc: 0.536000; val_acc: 0.346000\n (Iteration 121 / 200) loss: 1.550785\n (Epoch 7 / 10) train acc: 0.530000; val_acc: 0.310000\n (Iteration 141 / 200) loss: 1.436316\n (Epoch 8 / 10) train acc: 0.622000; val_acc: 0.342000\n (Iteration 161 / 200) loss: 1.001618\n (Epoch 9 / 10) train acc: 0.663000; val_acc: 0.332000\n (Iteration 181 / 200) loss: 0.922066\n (Epoch 10 / 10) train acc: 0.720000; val_acc: 0.338000\n\n\nRun the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster.\n\n\n```\ndef plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n \"\"\"utility function for plotting training history\"\"\"\n plt.title(title)\n plt.xlabel(label)\n bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n bl_plot = plot_fn(baseline)\n num_bn = len(bn_plots)\n for i in range(num_bn):\n label='with_norm'\n if labels is not None:\n label += str(labels[i])\n plt.plot(bn_plots[i], bn_marker, label=label)\n label='baseline'\n if labels is not None:\n label += str(labels[0])\n plt.plot(bl_plot, bl_marker, label=label)\n plt.legend(loc='lower center', ncol=num_bn+1) \n\n \nplt.subplot(3, 1, 1)\nplot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n lambda x: x.loss_history, bl_marker='o', bn_marker='o')\nplt.subplot(3, 1, 2)\nplot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\nplt.subplot(3, 1, 3)\nplot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n# Batch normalization and initialization\nWe will now run a small experiment to study the interaction of batch normalization and weight initialization.\n\nThe first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale.\n\n\n```\nnp.random.seed(231)\n# Try training a very deep net with batchnorm\nhidden_dims = [50, 50, 50, 50, 50, 50, 50]\nnum_train = 1000\nsmall_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n}\n\nbn_solvers_ws = {}\nsolvers_ws = {}\nweight_scales = np.logspace(-4, 0, num=20)\nfor i, weight_scale in enumerate(weight_scales):\n print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n\n bn_solver = Solver(bn_model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n bn_solver.train()\n bn_solvers_ws[weight_scale] = bn_solver\n\n solver = Solver(model, small_data,\n num_epochs=10, batch_size=50,\n update_rule='adam',\n optim_config={\n 'learning_rate': 1e-3,\n },\n verbose=False, print_every=200)\n solver.train()\n solvers_ws[weight_scale] = solver\n```\n\n Running weight scale 1 / 20\n Running weight scale 2 / 20\n Running weight scale 3 / 20\n Running weight scale 4 / 20\n Running weight scale 5 / 20\n Running weight scale 6 / 20\n Running weight scale 7 / 20\n Running weight scale 8 / 20\n Running weight scale 9 / 20\n Running weight scale 10 / 20\n Running weight scale 11 / 20\n Running weight scale 12 / 20\n Running weight scale 13 / 20\n Running weight scale 14 / 20\n Running weight scale 15 / 20\n Running weight scale 16 / 20\n Running weight scale 17 / 20\n Running weight scale 18 / 20\n Running weight scale 19 / 20\n Running weight scale 20 / 20\n\n\n\n```\n# Plot results of weight scale experiment\nbest_train_accs, bn_best_train_accs = [], []\nbest_val_accs, bn_best_val_accs = [], []\nfinal_train_loss, bn_final_train_loss = [], []\n\nfor ws in weight_scales:\n best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n \n best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n \n final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n \nplt.subplot(3, 1, 1)\nplt.title('Best val accuracy vs weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best val accuracy')\nplt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\nplt.legend(ncol=2, loc='lower right')\n\nplt.subplot(3, 1, 2)\nplt.title('Best train accuracy vs weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Best training accuracy')\nplt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\nplt.legend()\n\nplt.subplot(3, 1, 3)\nplt.title('Final training loss vs weight initialization scale')\nplt.xlabel('Weight initialization scale')\nplt.ylabel('Final training loss')\nplt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\nplt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\nplt.legend()\nplt.gca().set_ylim(1.0, 3.5)\n\nplt.gcf().set_size_inches(15, 15)\nplt.show()\n```\n\n## Inline Question 1:\nDescribe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?\n\n## Answer:\n[FILL THIS IN]\n\n\n# Batch normalization and batch size\nWe will now run a small experiment to study the interaction of batch normalization and batch size.\n\nThe first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time.\n\n\n```\ndef run_batchsize_experiments(normalization_mode):\n np.random.seed(231)\n # Try training a very deep net with batchnorm\n hidden_dims = [100, 100, 100, 100, 100]\n num_train = 1000\n small_data = {\n 'X_train': data['X_train'][:num_train],\n 'y_train': data['y_train'][:num_train],\n 'X_val': data['X_val'],\n 'y_val': data['y_val'],\n }\n n_epochs=10\n weight_scale = 2e-2\n batch_sizes = [5,10,50]\n lr = 10**(-3.5)\n solver_bsize = batch_sizes[0]\n\n print('No normalization: batch size = ',solver_bsize)\n model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n solver = Solver(model, small_data,\n num_epochs=n_epochs, batch_size=solver_bsize,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n solver.train()\n \n bn_solvers = []\n for i in range(len(batch_sizes)):\n b_size=batch_sizes[i]\n print('Normalization: batch size = ',b_size)\n bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n bn_solver = Solver(bn_model, small_data,\n num_epochs=n_epochs, batch_size=b_size,\n update_rule='adam',\n optim_config={\n 'learning_rate': lr,\n },\n verbose=False)\n bn_solver.train()\n bn_solvers.append(bn_solver)\n \n return bn_solvers, solver, batch_sizes\n\nbatch_sizes = [5,10,50]\nbn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')\n```\n\n No normalization: batch size = 5\n Normalization: batch size = 5\n Normalization: batch size = 10\n Normalization: batch size = 50\n\n\n\n```\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 2:\nDescribe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n\n## Answer:\n[FILL THIS IN]\n\n\n# Layer Normalization\nBatch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n\nSeveral alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [2]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n\n[2] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)\n\n## Inline Question 3:\nWhich of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n\n1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1. \n3. Subtracting the mean image of the dataset from each image in the dataset.\n4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n\n## Answer:\n[FILL THIS IN]\n\n\n# Layer Normalization: Implementation\n\nNow you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n\nHere's what you need to do:\n\n* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_forward`. \n\nRun the cell below to check your results.\n* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n\nRun the second cell below to check your results.\n* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n\nRun the third cell below to run the batch size experiment on layer normalization.\n\n\n```\n# Check the training-time forward pass by checking means and variances\n# of features both before and after layer normalization \n\n# Simulate the forward pass for a two-layer network\nnp.random.seed(231)\nN, D1, D2, D3 =4, 50, 60, 3\nX = np.random.randn(N, D1)\nW1 = np.random.randn(D1, D2)\nW2 = np.random.randn(D2, D3)\na = np.maximum(0, X.dot(W1)).dot(W2)\n\nprint('Before layer normalization:')\nprint_mean_std(a,axis=1)\n\ngamma = np.ones(D3)\nbeta = np.zeros(D3)\n# Means should be close to zero and stds close to one\nprint('After layer normalization (gamma=1, beta=0)')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n\ngamma = np.asarray([3.0,3.0,3.0])\nbeta = np.asarray([5.0,5.0,5.0])\n# Now means should be close to beta and stds close to gamma\nprint('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\na_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\nprint_mean_std(a_norm,axis=1)\n```\n\n Before layer normalization:\n means: [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n stds: [10.07429373 28.39478981 35.28360729 4.01831507]\n \n After layer normalization (gamma=1, beta=0)\n means: [ 4.81096644e-16 -7.40148683e-17 2.22044605e-16 -5.92118946e-16]\n stds: [0.99999995 0.99999999 1. 0.99999969]\n \n After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n means: [5. 5. 5. 5.]\n stds: [2.99999985 2.99999998 2.99999999 2.99999907]\n \n\n\n\n```\n# Gradient check batchnorm backward pass\nnp.random.seed(231)\nN, D = 4, 5\nx = 5 * np.random.randn(N, D) + 12\ngamma = np.random.randn(D)\nbeta = np.random.randn(D)\ndout = np.random.randn(N, D)\n\nln_param = {}\nfx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\nfg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\nfb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n\ndx_num = eval_numerical_gradient_array(fx, x, dout)\nda_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\ndb_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n\n_, cache = layernorm_forward(x, gamma, beta, ln_param)\ndx, dgamma, dbeta = layernorm_backward(dout, cache)\n\n#You should expect to see relative errors between 1e-12 and 1e-8\nprint('dx error: ', rel_error(dx_num, dx))\nprint('dgamma error: ', rel_error(da_num, dgamma))\nprint('dbeta error: ', rel_error(db_num, dbeta))\n```\n\n dx error: 1.4336158494902849e-09\n dgamma error: 4.519489546032799e-12\n dbeta error: 2.276445013433725e-12\n\n\n# Layer Normalization and batch size\n\nWe will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!\n\n\n```\nln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n\nplt.subplot(2, 1, 1)\nplot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\nplt.subplot(2, 1, 2)\nplot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n\nplt.gcf().set_size_inches(15, 10)\nplt.show()\n```\n\n## Inline Question 4:\nWhen is layer normalization likely to not work well, and why?\n\n1. Using it in a very deep network\n2. Having a very small dimension of features\n3. Having a high regularization term\n\n\n## Answer:\n[FILL THIS IN]\n\n", "meta": {"hexsha": "cf4107e87edbd3c4dc9c7cc4eee38c0fdb902c03", "size": 442814, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "assignment2/BatchNormalization.ipynb", "max_stars_repo_name": "Abhijeet8901/CS231n", "max_stars_repo_head_hexsha": "c8e715028b453899d5069cdb34faf3fc2959c270", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "assignment2/BatchNormalization.ipynb", "max_issues_repo_name": "Abhijeet8901/CS231n", "max_issues_repo_head_hexsha": "c8e715028b453899d5069cdb34faf3fc2959c270", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "assignment2/BatchNormalization.ipynb", "max_forks_repo_name": "Abhijeet8901/CS231n", "max_forks_repo_head_hexsha": "c8e715028b453899d5069cdb34faf3fc2959c270", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 442814.0, "max_line_length": 442814, "alphanum_fraction": 0.9384640052, "converted": true, "num_tokens": 9252, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4225046348141882, "lm_q2_score": 0.23934934732271168, "lm_q1q2_score": 0.1011262085835966}}
{"text": "+ This notebook is part of lecture 14 *Orthogonal vectors and subspaces* in the OCW MIT course 18.06 by Prof Gilbert Strang [1]\n+ Created by me, Dr Juan H Klopper\n + Head of Acute Care Surgery\n + Groote Schuur Hospital\n + University Cape Town\n + Email me with your thoughts, comments, suggestions and corrections \nLinear Algebra OCW MIT18.06 IPython notebook [2] study notes by Dr Juan H Klopper is licensed under a Creative Commons Attribution-NonCommercial 4.0 International License .\n\n+ [1] OCW MIT 18.06 \n+ [2] Fernando Pérez, Brian E. Granger, IPython: A System for Interactive Scientific Computing, Computing in Science and Engineering, vol. 9, no. 3, pp. 21-29, May/June 2007, doi:10.1109/MCSE.2007.53. URL: http://ipython.org\n\n\n```python\nfrom IPython.core.display import HTML, Image\n```\n\n\n```python\n# css_file = 'style.css'\n# HTML(open(css_file, 'r').read())\n```\n\n\n```python\nfrom sympy import init_printing, symbols, Matrix\nfrom warnings import filterwarnings\n```\n\n\n```python\ninit_printing(use_latex='mathjax')\nfilterwarnings('ignore')\n```\n\n# Orthogonal vectors and subspaces\n# Rowspace orthogonal to nullspace and columnspace to nullspace of AT \n# N(AT A) = N(A)\n\n## Orthogonal vectors\n\n* Two vectors are orthogonal if their dot product is zero\n* If they are written as column vectors **x** and **y**, their dot product is **x**T **y**\n * For orthogonal (perpendicular) vectors **x**T **y** = 0\n* From the Pythagorean theorem they are orthogonal if\n$$ { \\left\\| \\overline { x } \\right\\| }^{ 2 }+{ \\left\\| \\overline { y } \\right\\| }^{ 2 }={ \\left\\| \\overline { x } +\\overline { y } \\right\\| }^{ 2 }\\\\ { \\left\\| \\overline { x } \\right\\| }=\\sqrt { { x }_{ 1 }^{ 2 }+{ x }_{ 2 }^{ 2 }+\\dots +{ x }_{ b }^{ 2 } } $$\n\n* The length squared of a (column) vector **x** can be calculated by **x**T **x**\n* This achieves exactly the same as the sum of the squares of each element in the vector\n$$ { x }_{ 1 }^{ 2 }+{ x }_{ 2 }^{ 2 }+\\dots +{ x }_{ n }^{ 2 }$$\n\n* Following from the Pythagorean theorem we have\n$$ { \\left\\| \\overline { x } \\right\\| }^{ 2 }+{ \\left\\| \\overline { y } \\right\\| }^{ 2 }={ \\left\\| \\overline { x } +\\overline { y } \\right\\| }^{ 2 }\\\\ { \\underline { x } }^{ T }\\underline { x } +{ \\underline { y } }^{ T }\\underline { y } ={ \\left( \\underline { x } +\\underline { y } \\right) }^{ T }\\left( \\underline { x } +\\underline { y } \\right) \\\\ { \\underline { x } }^{ T }\\underline { x } +{ \\underline { y } }^{ T }\\underline { y } ={ \\underline { x } }^{ T }\\underline { x } +{ \\underline { x } }^{ T }\\underline { y } +{ \\underline { y } }^{ T }\\underline { x } +{ \\underline { y } }^{ T }\\underline { y } \\\\ \\because \\quad { \\underline { x } }^{ T }\\underline { y } ={ \\underline { y } }^{ T }\\underline { x } \\\\ { \\underline { x } }^{ T }\\underline { x } +{ \\underline { y } }^{ T }\\underline { y } ={ \\underline { x } }^{ T }\\underline { x } +2{ \\underline { x } }^{ T }\\underline { y } +{ \\underline { y } }^{ T }\\underline { y } \\\\ 2{ \\underline { x } }^{ T }\\underline { y } =0\\\\ { \\underline { x } }^{ T }\\underline { y } =0 $$\n* This states that the dot product of orthogonal vectors equal zero\n\n* The zero vector is orthogonal to all other similar dimensional vectors\n\n## Orthogonality of subspaces\n\n* Consider two subspaces *S* and *T*\n* To be orthogonal every vector in *S* must be orthogonal to any vector in *T*\n\n* Consider the *XY* and *YZ* planes in 3-space\n* They are not orthogonal, since many combinations of vectors (one in each plane) are not orthogonal\n* Vectors in the intersection, even though, one each from each plane can indeed be the same vector\n* We can say that any planes that intersect cannot be orthogonal to each other\n\n## Orthogonality of the rowspace and the nullspace\n\n* The nullspace contains vectors **x** such that A**x** = **0**\n* Now remembering that **x**T **y** = 0 for orthogonal column vectors and considering each row in A as a transposed column vector and **x** (indeed a column vector) and their product being zero meaning that they are orthogonal, we have:\n$$ \\begin{bmatrix} { { a }_{ 11 } } & { a }_{ 12 } & \\dots & { a }_{ 1n } \\\\ { a }_{ 21 } & { a }_{ 22 } & \\dots & { a }_{ 2n } \\\\ \\vdots & \\vdots & \\vdots & \\vdots \\\\ { a }_{ m1 } & { a }_{ m2 } & \\dots & { a }_{ mn } \\end{bmatrix}\\begin{bmatrix} { x }_{ 1 } \\\\ { x }_{ 2 } \\\\ \\vdots \\\\ { x }_{ n } \\end{bmatrix}=\\begin{bmatrix} 0 \\\\ 0 \\\\ \\vdots \\\\ 0 \\end{bmatrix}\\\\ \\begin{bmatrix} { a }_{ 11 } & { a }_{ 12 } & \\dots & { a }_{ 1n } \\end{bmatrix}\\begin{bmatrix} { x }_{ 1 } \\\\ { x }_{ 2 } \\\\ \\vdots \\\\ { x }_{ n } \\end{bmatrix}=0\\\\ \\dots $$\n\n* The rows (row vectors) in A are NOT the only vectors in the rowspace, since we also need to show that ALL linear combinations of them are also orthogonal to **x**\n* This is easy to see by the structure above\n\n## Orthogonality of the columnspace and the nullspace of AT \n\n* The proof is the same as above\n\n* The orthogonality of the rowspace and the nullspace is creating two orthogonal subspaces in ℝn \n* The orthogonality of the columnspace and the nullspace of AT is creating two orthogonal subspaces in ℝm \n\n* Note how the dimension add up to the degree of the space ℝ\n * The rowspace (a fundamental subspace in ℝn ) is of dimension *r*\n * The dimension of the nullspace (a fundamental subspace in ℝn ) is of dimension *n* - *r*\n * Addition of these dimensions gives us the dimension of the total space *n* as in ℝn \n * AND\n * The columnspace is of dimension *r* and the nullspace of AT is of dimension *m* - *r*, which adds to *m* as in ℝm \n\n* This means that two lines that may be orthogonal in ℝ3 cannot be two orthogonal subspaces of ℝ3 since the addition of the dimensions of these two subspaces (lines) is not 3 (as in ℝ3 )\n\n* We call this complementarity, i.e. the nullspace and rowspace are orthogonal *complements* in ℝn \n\n## AT A\n\n* We know that\n * The result is square\n * The result is symmetric, i.e. (*n*×*m*)(*m*×*n*)=*n*×*n*\n * (AT A)T = AT ATT = AT A\n\n* When A**x** = **b** is not solvable we use AT A**x** = AT **b**\n* **x** in the first instance did not have a solution, but after multiplying both side with AT , we hope that the second **x** has an solution, now called\n$$ {A}^{T}{A}\\hat{x} = {A}^{T}{b} $$\n\n\n* Consider the matrix below with *m* = 4 equation in *n* = 2 unknowns\n* The only **b** solutions must be linear combinations of the columnspace of A\n\n\n```python\nA = Matrix([[1, 1], [1, 2], [1, 5]])\nA\n```\n\n$$ {x}_{1} \\begin{bmatrix} 1 \\\\ 1 \\\\ 1 \\end{bmatrix} + {x}_{2} \\begin{bmatrix} 1 \\\\ 2 \\\\ 5 \\end{bmatrix} = \\begin{bmatrix} {b}_{1} \\\\ {b}_{2} \\\\ {b}_{3} \\end{bmatrix} $$\n\n\n```python\nA.transpose() * A\n```\n\n* Note how the nullspace of AT A is equal to the nullspace of A\n\n\n```python\n(A.transpose() * A).nullspace() == A.nullspace()\n```\n\n* The same goes for the rank\n\n\n```python\nA.rref(), (A.transpose() * A).rref()\n```\n\n* AT A is not always invertible\n* In fact it is only invertible if the nullspace of A only contains the zero vector (has independent columns)\n\n\n```python\n\n```\n", "meta": {"hexsha": "a071bbec169722bffdb07fbfbd0b1ed36413e172", "size": 11981, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "_math/MIT_OCW_18_06_Linear_algebra/II_01_Orthogonality_of_vectors_and_subspaces.ipynb", "max_stars_repo_name": "aixpact/data-science", "max_stars_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2020-07-22T23:12:39.000Z", "max_stars_repo_stars_event_max_datetime": "2020-07-25T02:30:48.000Z", "max_issues_repo_path": "_math/MIT_OCW_18_06_Linear_algebra/II_01_Orthogonality_of_vectors_and_subspaces.ipynb", "max_issues_repo_name": "aixpact/data-science", "max_issues_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "_math/MIT_OCW_18_06_Linear_algebra/II_01_Orthogonality_of_vectors_and_subspaces.ipynb", "max_forks_repo_name": "aixpact/data-science", "max_forks_repo_head_hexsha": "f04a54595fbc2d797918d450b979fd4c2eabac15", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.9783950617, "max_line_length": 1149, "alphanum_fraction": 0.5446123028, "converted": true, "num_tokens": 2604, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.476579651063676, "lm_q2_score": 0.21206879439743004, "lm_q1q2_score": 0.10106767203542165}}
{"text": "[Table of Contents](http://nbviewer.ipython.org/github/rlabbe/Kalman-and-Bayesian-Filters-in-Python/blob/master/table_of_contents.ipynb)\n\n# Kalman Filter Math\n\n\n```python\n#format the book\n%matplotlib inline\nfrom __future__ import division, print_function\nfrom book_format import load_style\nload_style()\n```\n\n\n\n\n\n\n\n\n\n\nIf you've gotten this far I hope that you are thinking that the Kalman filter's fearsome reputation is somewhat undeserved. Sure, I hand waved some equations away, but I hope implementation has been fairly straightforward for you. The underlying concept is quite straightforward - take two measurements, or a measurement and a prediction, and choose the output to be somewhere between the two. If you believe the measurement more your guess will be closer to the measurement, and if you believe the prediction is more accurate your guess will lie closer to it. That's not rocket science (little joke - it is exactly this math that got Apollo to the moon and back!). \n\nTo be honest I have been choosing my problems carefully. For an arbitrary problem designing the Kalman filter matrices can be extremely difficult. I haven't been *too tricky*, though. Equations like Newton's equations of motion can be trivially computed for Kalman filter applications, and they make up the bulk of the kind of problems that we want to solve. \n\nI have illustrated the concepts with code and reasoning, not math. But there are topics that do require more mathematics than I have used so far. This chapter presents the math that you will need for the rest of the book.\n\n## Modeling a Dynamic System\n\nA *dynamic system* is a physical system whose state (position, temperature, etc) evolves over time. Calculus is the math of changing values, so we use differential equations to model dynamic systems. Some systems cannot be modeled with differential equations, but we will not encounter those in this book.\n\nModeling dynamic systems is properly the topic of several college courses. To an extent there is no substitute for a few semesters of ordinary and partial differential equations followed by a graduate course in control system theory. If you are a hobbyist, or trying to solve one very specific filtering problem at work you probably do not have the time and/or inclination to devote a year or more to that education.\n\nFortunately, I can present enough of the theory to allow us to create the system equations for many different Kalman filters. My goal is to get you to the stage where you can read a publication and understand it well enough to implement the algorithms. The background math is deep, but in practice we end up using a few simple techniques. \n\nThis is the longest section of pure math in this book. You will need to master everything in this section to understand the Extended Kalman filter (EKF), the most common nonlinear filter. I do cover more modern filters that do not require as much of this math. You can choose to skim now, and come back to this if you decide to learn the EKF.\n\nWe need to start by understanding the underlying equations and assumptions that the Kalman filter uses. We are trying to model real world phenomena, so what do we have to consider?\n\nEach physical system has a process. For example, a car traveling at a certain velocity goes so far in a fixed amount of time, and its velocity varies as a function of its acceleration. We describe that behavior with the well known Newtonian equations that we learned in high school.\n\n$$\n\\begin{aligned}\nv&=at\\\\\nx &= \\frac{1}{2}at^2 + v_0t + x_0\n\\end{aligned}\n$$\n\nOnce we learned calculus we saw them in this form:\n\n$$ \\mathbf v = \\frac{d \\mathbf x}{d t}, \n\\quad \\mathbf a = \\frac{d \\mathbf v}{d t} = \\frac{d^2 \\mathbf x}{d t^2}\n$$\n\nA typical automobile tracking problem would have you compute the distance traveled given a constant velocity or acceleration, as we did in previous chapters. But, of course we know this is not all that is happening. No car travels on a perfect road. There are bumps, wind drag, and hills that raise and lower the speed. The suspension is a mechanical system with friction and imperfect springs.\n\nPerfectly modeling a system is impossible except for the most trivial problems. We are forced to make a simplification. At any time $t$ we say that the true state (such as the position of our car) is the predicted value from the imperfect model plus some unknown *process noise*:\n\n$$\nx(t) = x_{pred}(t) + noise(t)\n$$\n\nThis is not meant to imply that $noise(t)$ is a function that we can derive analytically. It is merely a statement of fact - we can always describe the true value as the predicted value plus the process noise. \"Noise\" does not imply random events. If we are tracking a thrown ball in the atmosphere, and our model assumes the ball is in a vacuum, then the effect of air drag is process noise in this context.\n\nIn the next section we will learn techniques to convert a set of higher order differential equations into a set of first-order differential equations. After the conversion the model of the system without noise is:\n\n$$ \\dot{\\mathbf x} = \\mathbf{Ax}$$\n\n$\\mathbf A$ is known as the *systems dynamics matrix* as it describes the dynamics of the system. Now we need to model the noise. We will call that $\\mathbf w$, and add it to the equation. \n\n$$ \\dot{\\mathbf x} = \\mathbf{Ax} + \\mathbf w$$\n\n$\\mathbf w$ may strike you as a poor choice for the name, but you will soon see that the Kalman filter assumes *white* noise.\n\nFinally, we need to consider any inputs into the system. We assume an input $\\mathbf u$, and that there exists a linear model that defines how that input changes the system. For example, pressing the accelerator in your car makes it accelerate, and gravity causes balls to fall. Both are contol inputs. We will need a matrix $\\mathbf B$ to convert $u$ into the effect on the system. We add that into our equation:\n\n$$ \\dot{\\mathbf x} = \\mathbf{Ax} + \\mathbf{Bu} + \\mathbf{w}$$\n\nAnd that's it. That is one of the equations that Dr. Kalman set out to solve, and he found an optimal estimator if we assume certain properties of $\\mathbf w$.\n\n## State-Space Representation of Dynamic Systems\n\nWe've derived the equation\n\n$$ \\dot{\\mathbf x} = \\mathbf{Ax}+ \\mathbf{Bu} + \\mathbf{w}$$\n\nHowever, we are not interested in the derivative of $\\mathbf x$, but in $\\mathbf x$ itself. Ignoring the noise for a moment, we want an equation that recusively finds the value of $\\mathbf x$ at time $t_k$ in terms of $\\mathbf x$ at time $t_{k-1}$:\n\n$$\\mathbf x(t_k) = \\mathbf F(\\Delta t)\\mathbf x(t_{k-1}) + \\mathbf B(t_k)\\mathbf u (t_k)$$\n\nConvention allows us to write $\\mathbf x(t_k)$ as $\\mathbf x_k$, which means the \nthe value of $\\mathbf x$ at the k$^{th}$ value of $t$.\n\n$$\\mathbf x_k = \\mathbf{Fx}_{k-1} + \\mathbf B_k\\mathbf u_k$$\n\n$\\mathbf F$ is the familiar *state transition matrix*, named due to its ability to transition the state's value between discrete time steps. It is very similar to the system dynamics matrix $\\mathbf A$. The difference is that $\\mathbf A$ models a set of linear differential equations, and is continuous. $\\mathbf F$ is discrete, and represents a set of linear equations (not differential equations) which transitions $\\mathbf x_{k-1}$ to $\\mathbf x_k$ over a discrete time step $\\Delta t$. \n\nFinding this matrix is often quite difficult. The equation $\\dot x = v$ is the simplest possible differential equation and we trivially integrate it as:\n\n$$ \\int\\limits_{x_{k-1}}^{x_k} \\mathrm{d}x = \\int\\limits_{0}^{\\Delta t} v\\, \\mathrm{d}t $$\n$$x_k-x_0 = v \\Delta t$$\n$$x_k = v \\Delta t + x_0$$\n\nThis equation is *recursive*: we compute the value of $x$ at time $t$ based on its value at time $t-1$. This recursive form enables us to represent the system (process model) in the form required by the Kalman filter:\n\n$$\\begin{aligned}\n\\mathbf x_k &= \\mathbf{Fx}_{k-1} \\\\\n&= \\begin{bmatrix} 1 & \\Delta t \\\\ 0 & 1\\end{bmatrix}\n\\begin{bmatrix}x_{k-1} \\\\ \\dot x_{k-1}\\end{bmatrix}\n\\end{aligned}$$\n\nWe can do that only because $\\dot x = v$ is simplest differential equation possible. Almost all other in physical systems result in more complicated differential equation which do not yield to this approach. \n\n*State-space* methods became popular around the time of the Apollo missions, largely due to the work of Dr. Kalman. The idea is simple. Model a system with a set of $n^{th}$-order differential equations. Convert them into an equivalent set of first-order differential equations. Put them into the vector-matrix form used in the previous section: $\\dot{\\mathbf x} = \\mathbf{Ax} + \\mathbf{Bu}$. Once in this form we use of of several techniques to convert these linear differential equations into the recursive equation:\n\n$$ \\mathbf x_k = \\mathbf{Fx}_{k-1} + \\mathbf B_k\\mathbf u_k$$\n\nSome books call the state transition matrix the *fundamental matrix*. Many use $\\mathbf \\Phi$ instead of $\\mathbf F$. Sources based heavily on control theory tend to use these forms.\n\nThese are called *state-space* methods because we are expressing the solution of the differential equations in terms of the system state. \n\n### Forming First Order Equations from Higher Order Equations\n\nMany models of physical systems require second or higher order differential equations with control input $u$:\n\n$$a_n \\frac{d^ny}{dt^n} + a_{n-1} \\frac{d^{n-1}y}{dt^{n-1}} + \\dots + a_2 \\frac{d^2y}{dt^2} + a_1 \\frac{dy}{dt} + a_0 = u$$\n\nState-space methods require first-order equations. Any higher order system of equations can be reduced to first-order by defining extra variables for the derivatives and then solving. \n\n\nLet's do an example. Given the system $\\ddot{x} - 6\\dot x + 9x = u$ find the equivalent first order equations. I've used the dot notation for the time derivatives for clarity.\n\nThe first step is to isolate the highest order term onto one side of the equation.\n\n$$\\ddot{x} = 6\\dot x - 9x + u$$\n\nWe define two new variables:\n\n$$\\begin{aligned} x_1(u) &= x \\\\\nx_2(u) &= \\dot x\n\\end{aligned}$$\n\nNow we will substitute these into the original equation and solve. The solution yields a set of first-order equations in terms of these new variables. It is conventional to drop the $(u)$ for notational convenience.\n\nWe know that $\\dot x_1 = x_2$ and that $\\dot x_2 = \\ddot{x}$. Therefore\n\n$$\\begin{aligned}\n\\dot x_2 &= \\ddot{x} \\\\\n &= 6\\dot x - 9x + t\\\\\n &= 6x_2-9x_1 + t\n\\end{aligned}$$\n\nTherefore our first-order system of equations is\n\n$$\\begin{aligned}\\dot x_1 &= x_2 \\\\\n\\dot x_2 &= 6x_2-9x_1 + t\\end{aligned}$$\n\nIf you practice this a bit you will become adept at it. Isolate the highest term, define a new variable and its derivatives, and then substitute.\n\n### First Order Differential Equations In State-Space Form\n\nSubstituting the newly defined variables from the previous section:\n\n$$\\frac{dx_1}{dt} = x_2,\\, \n\\frac{dx_2}{dt} = x_3, \\, ..., \\, \n\\frac{dx_{n-1}}{dt} = x_n$$\n\ninto the first order equations yields: \n\n$$\\frac{dx_n}{dt} = \\frac{1}{a_n}\\sum\\limits_{i=0}^{n-1}a_ix_{i+1} + \\frac{1}{a_n}u\n$$\n\n\nUsing vector-matrix notation we have:\n\n$$\\begin{bmatrix}\\frac{dx_1}{dt} \\\\ \\frac{dx_2}{dt} \\\\ \\vdots \\\\ \\frac{dx_n}{dt}\\end{bmatrix} = \n\\begin{bmatrix}\\dot x_1 \\\\ \\dot x_2 \\\\ \\vdots \\\\ \\dot x_n\\end{bmatrix}=\n\\begin{bmatrix}0 & 1 & 0 &\\cdots & 0 \\\\\n0 & 0 & 1 & \\cdots & 0 \\\\\n\\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n-\\frac{a_0}{a_n} & -\\frac{a_1}{a_n} & -\\frac{a_2}{a_n} & \\cdots & -\\frac{a_{n-1}}{a_n}\\end{bmatrix}\n\\begin{bmatrix}x_1 \\\\ x_2 \\\\ \\vdots \\\\ x_n\\end{bmatrix} + \n\\begin{bmatrix}0 \\\\ 0 \\\\ \\vdots \\\\ \\frac{1}{a_n}\\end{bmatrix}u$$\n\nwhich we then write as $\\dot{\\mathbf x} = \\mathbf{Ax} + \\mathbf{B}u$.\n\n### Finding the Fundamental Matrix for Time Invariant Systems\n\nWe express the system equations in state-space form with\n\n$$ \\dot{\\mathbf x} = \\mathbf{Ax}$$\n\nwhere $\\mathbf A$ is the system dynamics matrix, and want to find the *fundamental matrix* $\\mathbf F$ that propagates the state $\\mathbf x$ over the interval $\\Delta t$ with the equation\n\n$$\\begin{aligned}\n\\mathbf x(t_k) = \\mathbf F(\\Delta t)\\mathbf x(t_{k-1})\\end{aligned}$$\n\nIn other words, $\\mathbf A$ is a set of continuous differential equations, and we need $\\mathbf F$ to be a set of discrete linear equations that computes the change in $\\mathbf A$ over a discrete time step.\n\nIt is conventional to drop the $t_k$ and $(\\Delta t)$ and use the notation\n\n$$\\mathbf x_k = \\mathbf {Fx}_{k-1}$$\n\nBroadly speaking there are three common ways to find this matrix for Kalman filters. The technique most often used is the matrix exponential. Linear Time Invariant Theory, also known as LTI System Theory, is a second technique. Finally, there are numerical techniques. You may know of others, but these three are what you will most likely encounter in the Kalman filter literature and praxis.\n\n### The Matrix Exponential\n\nThe solution to the equation $\\frac{dx}{dt} = kx$ can be found by:\n\n$$\\begin{gathered}\\frac{dx}{dt} = kx \\\\\n\\frac{dx}{x} = k\\, dt \\\\\n\\int \\frac{1}{x}\\, dx = \\int k\\, dt \\\\\n\\log x = kt + c \\\\\nx = e^{kt+c} \\\\\nx = e^ce^{kt} \\\\\nx = c_0e^{kt}\\end{gathered}$$\n\nUsing similar math, the solution to the first-order equation \n\n$$\\dot{\\mathbf x} = \\mathbf{Ax} ,\\, \\, \\, \\mathbf x(0) = \\mathbf x_0$$\n\nwhere $\\mathbf A$ is a constant matrix, is\n\n$$\\mathbf x = e^{\\mathbf At}\\mathbf x_0$$\n\nSubstituting $F = e^{\\mathbf At}$, we can write \n\n$$\\mathbf x_k = \\mathbf F\\mathbf x_{k-1}$$\n\nwhich is the form we are looking for! We have reduced the problem of finding the fundamental matrix to one of finding the value for $e^{\\mathbf At}$.\n\n$e^{\\mathbf At}$ is known as the [matrix exponential](https://en.wikipedia.org/wiki/Matrix_exponential). It can be computed with this power series:\n\n$$e^{\\mathbf At} = \\mathbf{I} + \\mathbf{A}t + \\frac{(\\mathbf{A}t)^2}{2!} + \\frac{(\\mathbf{A}t)^3}{3!} + ... $$\n\nThat series is found by doing a Taylor series expansion of $e^{\\mathbf At}$, which I will not cover here.\n\nLet's use this to find the solution to Newton's equations. Using $v$ as an substitution for $\\dot x$, and assuming constant velocity we get the linear matrix-vector form \n\n$$\\begin{bmatrix}\\dot x \\\\ \\dot v\\end{bmatrix} =\\begin{bmatrix}0&1\\\\0&0\\end{bmatrix} \\begin{bmatrix}x \\\\ v\\end{bmatrix}$$\n\nThis is a first order differential equation, so we can set $\\mathbf{A}=\\begin{bmatrix}0&1\\\\0&0\\end{bmatrix}$ and solve the following equation. I have substituted the interval $\\Delta t$ for $t$ to emphasize that the fundamental matrix is discrete:\n\n$$\\mathbf F = e^{\\mathbf A\\Delta t} = \\mathbf{I} + \\mathbf A\\Delta t + \\frac{(\\mathbf A\\Delta t)^2}{2!} + \\frac{(\\mathbf A\\Delta t)^3}{3!} + ... $$\n\nIf you perform the multiplication you will find that $\\mathbf{A}^2=\\begin{bmatrix}0&0\\\\0&0\\end{bmatrix}$, which means that all higher powers of $\\mathbf{A}$ are also $\\mathbf{0}$. Thus we get an exact answer without an infinite number of terms:\n\n$$\n\\begin{aligned}\n\\mathbf F &=\\mathbf{I} + \\mathbf A \\Delta t + \\mathbf{0} \\\\\n&= \\begin{bmatrix}1&0\\\\0&1\\end{bmatrix} + \\begin{bmatrix}0&1\\\\0&0\\end{bmatrix}\\Delta t\\\\\n&= \\begin{bmatrix}1&\\Delta t\\\\0&1\\end{bmatrix}\n\\end{aligned}$$\n\nWe plug this into $\\mathbf x_k= \\mathbf{Fx}_{k-1}$ to get\n\n$$\n\\begin{aligned}\nx_k &=\\begin{bmatrix}1&\\Delta t\\\\0&1\\end{bmatrix}x_{k-1}\n\\end{aligned}$$\n\nYou will recognize this as the matrix we derived analytically for the constant velocity Kalman filter in the **Multivariate Kalman Filter** chapter.\n\nSciPy's linalg module includes a routine `expm()` to compute the matrix exponential. It does not use the Taylor series method, but the [Padé Approximation](https://en.wikipedia.org/wiki/Pad%C3%A9_approximant). There are many (at least 19) methods to computed the matrix exponential, and all suffer from numerical difficulties[1]. But you should be aware of the problems, especially when $\\mathbf A$ is large. If you search for \"pade approximation matrix exponential\" you will find many publications devoted to this problem. \n\nIn practice this may not be of concern to you as for the Kalman filter we normally just take the first two terms of the Taylor series. But don't assume my treatment of the problem is complete and run off and try to use this technique for other problem without doing a numerical analysis of the performance of this technique. Interestingly, one of the favored ways of solving $e^{\\mathbf At}$ is to use a generalized ode solver. In other words, they do the opposite of what we do - turn $\\mathbf A$ into a set of differential equations, and then solve that set using numerical techniques! \n\nHere is an example of using `expm()` to solve $e^{\\mathbf At}$.\n\n\n```python\nimport numpy as np\nfrom scipy.linalg import expm\n\ndt = 0.1\nA = np.array([[0, 1], \n [0, 0]])\nexpm(A*dt)\n```\n\n\n\n\n array([[ 1.0, 0.1],\n [ 0.0, 1.0]])\n\n\n\n### Time Invariance\n\nIf the behavior of the system depends on time we can say that a dynamic system is described by the first-order differential equation\n\n$$ g(t) = \\dot x$$\n\nHowever, if the system is *time invariant* the equation is of the form:\n\n$$ f(x) = \\dot x$$\n\nWhat does *time invariant* mean? Consider a home stereo. If you input a signal $x$ into it at time $t$, it will output some signal $f(x)$. If you instead perform the input at time $t + \\Delta t$ the output signal will be the same $f(x)$, shifted in time.\n\nA counter-example is $x(t) = \\sin(t)$, with the system $f(x) = t\\, x(t) = t \\sin(t)$. This is not time invariant; the value will be different at different times due to the multiplication by t. An aircraft is not time invariant. If you make a control input to the aircraft at a later time its behavior will be different because it will have burned fuel and thus lost weight. Lower weight results in different behavior.\n\nWe can solve these equations by integrating each side. I demonstrated integrating the time invariant system $v = \\dot x$ above. However, integrating the time invariant equation $\\dot x = f(x)$ is not so straightforward. Using the *separation of variables* techniques we divide by $f(x)$ and move the $dt$ term to the right so we can integrate each side:\n\n$$\\begin{gathered}\n\\frac{dx}{dt} = f(x) \\\\\n\\int^x_{x_0} \\frac{1}{f(x)} dx = \\int^t_{t_0} dt\n\\end{gathered}$$\n\nIf we let $F(x) = \\int \\frac{1}{f(x)} dx$ we get\n\n$$F(x) - F(x_0) = t-t_0$$\n\nWe then solve for x with\n\n$$\\begin{gathered}\nF(x) = t - t_0 + F(x_0) \\\\\nx = F^{-1}[t-t_0 + F(x_0)]\n\\end{gathered}$$\n\nIn other words, we need to find the inverse of $F$. This is not trivial, and a significant amount of coursework in a STEM education is devoted to finding tricky, analytic solutions to this problem. \n\nHowever, they are tricks, and many simple forms of $f(x)$ either have no closed form solution or pose extreme difficulties. Instead, the practicing engineer turns to state-space methods to find approximate solutions.\n\nThe advantage of the matrix exponential is that we can use it for any arbitrary set of differential equations which are *time invariant*. However, we often use this technique even when the equations are not time invariant. As an aircraft flies it burns fuel and loses weight. However, the weight loss over one second is negligible, and so the system is nearly linear over that time step. Our answers will still be reasonably accurate so long as the time step is short.\n\n#### Example: Mass-Spring-Damper Model\n\nSuppose we wanted to track the motion of a weight on a spring and connected to a damper, such as an automobile's suspension. The equation for the motion with $m$ being the mass, $k$ the spring constant, and $c$ the damping force, under some input $u$ is \n\n$$m\\frac{d^2x}{dt^2} + c\\frac{dx}{dt} +kx = u$$\n\nFor notational convenience I will write that as\n\n$$m\\ddot x + c\\dot x + kx = u$$\n\nI can turn this into a system of first order equations by setting $x_1(t)=x(t)$, and then substituting as follows:\n\n$$\\begin{aligned}\nx_1 &= x \\\\\nx_2 &= \\dot x_1 \\\\\n\\dot x_2 &= \\dot x_1 = \\ddot x\n\\end{aligned}$$\n\nAs is common I dropped the $(t)$ for notational convenience. This gives the equation\n\n$$m\\dot x_2 + c x_2 +kx_1 = u$$\n\nSolving for $\\dot x_2$ we get a first order equation:\n\n$$\\dot x_2 = -\\frac{c}{m}x_2 - \\frac{k}{m}x_1 + \\frac{1}{m}u$$\n\nWe put this into matrix form:\n\n$$\\begin{bmatrix} \\dot x_1 \\\\ \\dot x_2 \\end{bmatrix} = \n\\begin{bmatrix}0 & 1 \\\\ -k/m & -c/m \\end{bmatrix}\n\\begin{bmatrix} x_1 \\\\ x_2 \\end{bmatrix} + \n\\begin{bmatrix} 0 \\\\ 1/m \\end{bmatrix}u$$\n\nNow we use the matrix exponential to find the state transition matrix:\n\n$$\\Phi(t) = e^{\\mathbf At} = \\mathbf{I} + \\mathbf At + \\frac{(\\mathbf At)^2}{2!} + \\frac{(\\mathbf At)^3}{3!} + ... $$\n\nThe first two terms give us\n\n$$\\mathbf F = \\begin{bmatrix}1 & t \\\\ -(k/m) t & 1-(c/m) t \\end{bmatrix}$$\n\nThis may or may not give you enough precision. You can easily check this by computing $\\frac{(\\mathbf At)^2}{2!}$ for your constants and seeing how much this matrix contributes to the results.\n\n### Linear Time Invariant Theory\n\n[*Linear Time Invariant Theory*](https://en.wikipedia.org/wiki/LTI_system_theory), also known as LTI System Theory, gives us a way to find $\\Phi$ using the inverse Laplace transform. You are either nodding your head now, or completely lost. I will not be using the Laplace transform in this book. LTI system theory tells us that \n\n$$ \\Phi(t) = \\mathcal{L}^{-1}[(s\\mathbf{I} - \\mathbf{A})^{-1}]$$\n\nI have no intention of going into this other than to say that the Laplace transform $\\mathcal{L}$ converts a signal into a space $s$ that excludes time, but finding a solution to the equation above is non-trivial. If you are interested, the Wikipedia article on LTI system theory provides an introduction. I mention LTI because you will find some literature using it to design the Kalman filter matrices for difficult problems. \n\n### Numerical Solutions\n\nFinally, there are numerical techniques to find $\\mathbf F$. As filters get larger finding analytical solutions becomes very tedious (though packages like SymPy make it easier). C. F. van Loan [2] has developed a technique that finds both $\\Phi$ and $\\mathbf Q$ numerically. Given the continuous model\n\n$$ \\dot x = Ax + Gw$$\n\nwhere $w$ is the unity white noise, van Loan's method computes both $\\mathbf F_k$ and $\\mathbf Q_k$.\n \nI have implemented van Loan's method in `FilterPy`. You may use it as follows:\n\n```python\nfrom filterpy.common import van_loan_discretization\n\nA = np.array([[0., 1.], [-1., 0.]])\nG = np.array([[0.], [2.]]) # white noise scaling\nF, Q = van_loan_discretization(A, G, dt=0.1)\n```\n \nIn the section *Numeric Integration of Differential Equations* I present alternative methods which are very commonly used in Kalman filtering.\n\n## Design of the Process Noise Matrix\n\nIn general the design of the $\\mathbf Q$ matrix is among the most difficult aspects of Kalman filter design. This is due to several factors. First, the math requires a good foundation in signal theory. Second, we are trying to model the noise in something for which we have little information. Consider trying to model the process noise for a thrown baseball. We can model it as a sphere moving through the air, but that leaves many unknown factors - the wind, ball rotation and spin decay, the coefficient of drag of a ball with stitches, the effects of wind and air density, and so on. We develop the equations for an exact mathematical solution for a given process model, but since the process model is incomplete the result for $\\mathbf Q$ will also be incomplete. This has a lot of ramifications for the behavior of the Kalman filter. If $\\mathbf Q$ is too small then the filter will be overconfident in its prediction model and will diverge from the actual solution. If $\\mathbf Q$ is too large than the filter will be unduly influenced by the noise in the measurements and perform sub-optimally. In practice we spend a lot of time running simulations and evaluating collected data to try to select an appropriate value for $\\mathbf Q$. But let's start by looking at the math.\n\n\nLet's assume a kinematic system - some system that can be modeled using Newton's equations of motion. We can make a few different assumptions about this process. \n\nWe have been using a process model of\n\n$$ \\dot{\\mathbf x} = \\mathbf{Ax} + \\mathbf{Bu} + \\mathbf{w}$$\n\nwhere $\\mathbf{w}$ is the process noise. Kinematic systems are *continuous* - their inputs and outputs can vary at any arbitrary point in time. However, our Kalman filters are *discrete* (there are continuous forms for Kalman filters, but we do not cover them in this book). We sample the system at regular intervals. Therefore we must find the discrete representation for the noise term in the equation above. This depends on what assumptions we make about the behavior of the noise. We will consider two different models for the noise.\n\n### Continuous White Noise Model\n\nWe model kinematic systems using Newton's equations. We have either used position and velocity, or position, velocity, and acceleration as the models for our systems. There is nothing stopping us from going further - we can model jerk, jounce, snap, and so on. We don't do that normally because adding terms beyond the dynamics of the real system degrades the estimate. \n\nLet's say that we need to model the position, velocity, and acceleration. We can then assume that acceleration is constant for each discrete time step. Of course, there is process noise in the system and so the acceleration is not actually constant. The tracked object will alter the acceleration over time due to external, unmodeled forces. In this section we will assume that the acceleration changes by a continuous time zero-mean white noise $w(t)$. In other words, we are assuming that the small changes in velocity average to 0 over time (zero-mean). \n\nSince the noise is changing continuously we will need to integrate to get the discrete noise for the discretization interval that we have chosen. We will not prove it here, but the equation for the discretization of the noise is\n\n$$\\mathbf Q = \\int_0^{\\Delta t} \\mathbf F(t)\\mathbf{Q_c}\\mathbf F^\\mathsf{T}(t) dt$$\n\nwhere $\\mathbf{Q_c}$ is the continuous noise. The general reasoning should be clear. $\\mathbf F(t)\\mathbf{Q_c}\\mathbf F^\\mathsf{T}(t)$ is a projection of the continuous noise based on our process model $\\mathbf F(t)$ at the instant $t$. We want to know how much noise is added to the system over a discrete intervat $\\Delta t$, so we integrate this expression over the interval $[0, \\Delta t]$. \n\nWe know the fundamental matrix for Newtonian systems is\n\n$$F = \\begin{bmatrix}1 & \\Delta t & {\\Delta t}^2/2 \\\\ 0 & 1 & \\Delta t\\\\ 0& 0& 1\\end{bmatrix}$$\n\nWe define the continuous noise as \n\n$$\\mathbf{Q_c} = \\begin{bmatrix}0&0&0\\\\0&0&0\\\\0&0&1\\end{bmatrix} \\Phi_s$$\n\nwhere $\\Phi_s$ is the spectral density of the white noise. This can be derived, but is beyond the scope of this book. See any standard text on stochastic processes for the details. In practice we often do not know the spectral density of the noise, and so this turns into an \"engineering\" factor - a number we experimentally tune until our filter performs as we expect. You can see that the matrix that $\\Phi_s$ is multiplied by effectively assigns the power spectral density to the acceleration term. This makes sense; we assume that the system has constant acceleration except for the variations caused by noise. The noise alters the acceleration.\n\nWe could carry out these computations ourselves, but I prefer using SymPy to solve the equation.\n\n$$\\mathbf{Q_c} = \\begin{bmatrix}0&0&0\\\\0&0&0\\\\0&0&1\\end{bmatrix} \\Phi_s$$\n\n\n\n\n```python\nimport sympy\nfrom sympy import (init_printing, Matrix,MatMul, \n integrate, symbols)\n\ninit_printing(use_latex='mathjax')\ndt, phi = symbols('\\Delta{t} \\Phi_s')\nF_k = Matrix([[1, dt, dt**2/2],\n [0, 1, dt],\n [0, 0, 1]])\nQ_c = Matrix([[0, 0, 0],\n [0, 0, 0],\n [0, 0, 1]])*phi\n\nQ=sympy.integrate(F_k * Q_c * F_k.T, (dt, 0, dt))\n\n# factor phi out of the matrix to make it more readable\nQ = Q / phi\nsympy.MatMul(Q, phi)\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{\\Delta{t}^{5}}{20} & \\frac{\\Delta{t}^{4}}{8} & \\frac{\\Delta{t}^{3}}{6}\\\\\\frac{\\Delta{t}^{4}}{8} & \\frac{\\Delta{t}^{3}}{3} & \\frac{\\Delta{t}^{2}}{2}\\\\\\frac{\\Delta{t}^{3}}{6} & \\frac{\\Delta{t}^{2}}{2} & \\Delta{t}\\end{matrix}\\right] \\Phi_s$$\n\n\n\nFor completeness, let us compute the equations for the 0th order and 1st order equations.\n\n\n```python\nF_k = sympy.Matrix([[1]])\nQ_c = sympy.Matrix([[phi]])\n\nprint('0th order discrete process noise')\nsympy.integrate(F_k*Q_c*F_k.T,(dt, 0, dt))\n```\n\n 0th order discrete process noise\n\n\n\n\n\n$$\\left[\\begin{matrix}\\Delta{t} \\Phi_s\\end{matrix}\\right]$$\n\n\n\n\n```python\nF_k = sympy.Matrix([[1, dt],\n [0, 1]])\nQ_c = sympy.Matrix([[0, 0],\n [0, 1]])*phi\n\nQ = sympy.integrate(F_k * Q_c * F_k.T, (dt, 0, dt))\n\nprint('1st order discrete process noise')\n# factor phi out of the matrix to make it more readable\nQ = Q / phi\nsympy.MatMul(Q, phi)\n```\n\n 1st order discrete process noise\n\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{\\Delta{t}^{3}}{3} & \\frac{\\Delta{t}^{2}}{2}\\\\\\frac{\\Delta{t}^{2}}{2} & \\Delta{t}\\end{matrix}\\right] \\Phi_s$$\n\n\n\n### Piecewise White Noise Model\n\nAnother model for the noise assumes that the that highest order term (say, acceleration) is constant for the duration of each time period, but differs for each time period, and each of these is uncorrelated between time periods. In other words there is a discontinuous jump in acceleration at each time step. This is subtly different than the model above, where we assumed that the last term had a continuously varying noisy signal applied to it. \n\nWe will model this as\n\n$$f(x)=Fx+\\Gamma w$$\n\nwhere $\\Gamma$ is the *noise gain* of the system, and $w$ is the constant piecewise acceleration (or velocity, or jerk, etc). \n\nLet's start by looking at a first order system. In this case we have the state transition function\n\n$$\\mathbf{F} = \\begin{bmatrix}1&\\Delta t \\\\ 0& 1\\end{bmatrix}$$\n\nIn one time period, the change in velocity will be $w(t)\\Delta t$, and the change in position will be $w(t)\\Delta t^2/2$, giving us\n\n$$\\Gamma = \\begin{bmatrix}\\frac{1}{2}\\Delta t^2 \\\\ \\Delta t\\end{bmatrix}$$\n\nThe covariance of the process noise is then\n\n$$Q = \\mathbb E[\\Gamma w(t) w(t) \\Gamma^\\mathsf{T}] = \\Gamma\\sigma^2_v\\Gamma^\\mathsf{T}$$.\n\nWe can compute that with SymPy as follows\n\n\n```python\nvar=symbols('sigma^2_v')\nv = Matrix([[dt**2 / 2], [dt]])\n\nQ = v * var * v.T\n\n# factor variance out of the matrix to make it more readable\nQ = Q / var\nsympy.MatMul(Q, var)\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{\\Delta{t}^{4}}{4} & \\frac{\\Delta{t}^{3}}{2}\\\\\\frac{\\Delta{t}^{3}}{2} & \\Delta{t}^{2}\\end{matrix}\\right] \\sigma^{2}_{v}$$\n\n\n\nThe second order system proceeds with the same math.\n\n\n$$\\mathbf{F} = \\begin{bmatrix}1 & \\Delta t & {\\Delta t}^2/2 \\\\ 0 & 1 & \\Delta t\\\\ 0& 0& 1\\end{bmatrix}$$\n\nHere we will assume that the white noise is a discrete time Wiener process. This gives us\n\n$$\\Gamma = \\begin{bmatrix}\\frac{1}{2}\\Delta t^2 \\\\ \\Delta t\\\\ 1\\end{bmatrix}$$\n\nThere is no 'truth' to this model, it is just convenient and provides good results. For example, we could assume that the noise is applied to the jerk at the cost of a more complicated equation. \n\nThe covariance of the process noise is then\n\n$$Q = \\mathbb E[\\Gamma w(t) w(t) \\Gamma^\\mathsf{T}] = \\Gamma\\sigma^2_v\\Gamma^\\mathsf{T}$$.\n\nWe can compute that with SymPy as follows\n\n\n```python\nvar=symbols('sigma^2_v')\nv = Matrix([[dt**2 / 2], [dt], [1]])\n\nQ = v * var * v.T\n\n# factor variance out of the matrix to make it more readable\nQ = Q / var\nsympy.MatMul(Q, var)\n```\n\n\n\n\n$$\\left[\\begin{matrix}\\frac{\\Delta{t}^{4}}{4} & \\frac{\\Delta{t}^{3}}{2} & \\frac{\\Delta{t}^{2}}{2}\\\\\\frac{\\Delta{t}^{3}}{2} & \\Delta{t}^{2} & \\Delta{t}\\\\\\frac{\\Delta{t}^{2}}{2} & \\Delta{t} & 1\\end{matrix}\\right] \\sigma^{2}_{v}$$\n\n\n\nWe cannot say that this model is more or less correct than the continuous model - both are approximations to what is happening to the actual object. Only experience and experiments can guide you to the appropriate model. In practice you will usually find that either model provides reasonable results, but typically one will perform better than the other.\n\nThe advantage of the second model is that we can model the noise in terms of $\\sigma^2$ which we can describe in terms of the motion and the amount of error we expect. The first model requires us to specify the spectral density, which is not very intuitive, but it handles varying time samples much more easily since the noise is integrated across the time period. However, these are not fixed rules - use whichever model (or a model of your own devising) based on testing how the filter performs and/or your knowledge of the behavior of the physical model.\n\nA good rule of thumb is to set $\\sigma$ somewhere from $\\frac{1}{2}\\Delta a$ to $\\Delta a$, where $\\Delta a$ is the maximum amount that the acceleration will change between sample periods. In practice we pick a number, run simulations on data, and choose a value that works well.\n\n### Using FilterPy to Compute Q\n\nFilterPy offers several routines to compute the $\\mathbf Q$ matrix. The function `Q_continuous_white_noise()` computes $\\mathbf Q$ for a given value for $\\Delta t$ and the spectral density.\n\n\n```python\nfrom filterpy.common import Q_continuous_white_noise\nfrom filterpy.common import Q_discrete_white_noise\n\nQ = Q_continuous_white_noise(dim=2, dt=1, spectral_density=1)\nprint(Q)\n```\n\n [[ 0.333 0.5]\n [ 0.5 1.0]]\n\n\n\n```python\nQ = Q_continuous_white_noise(dim=3, dt=1, spectral_density=1)\nprint(Q)\n```\n\n [[ 0.05 0.125 0.167]\n [ 0.125 0.333 0.5]\n [ 0.167 0.5 1.0]]\n\n\nThe function `Q_discrete_white_noise()` computes $\\mathbf Q$ assuming a piecewise model for the noise.\n\n\n```python\nQ = Q_discrete_white_noise(2, var=1.)\nprint(Q)\n```\n\n [[ 0.25 0.5]\n [ 0.5 1.0]]\n\n\n\n```python\nQ = Q_discrete_white_noise(3, var=1.)\nprint(Q)\n```\n\n [[ 0.25 0.5 0.5]\n [ 0.5 1.0 1.0]\n [ 0.5 1.0 1.0]]\n\n\n### Simplification of Q\n\nMany treatments use a much simpler form for $\\mathbf Q$, setting it to zero except for a noise term in the lower rightmost element. Is this justified? Well, consider the value of $\\mathbf Q$ for a small $\\Delta t$\n\n\n```python\nimport numpy as np\n\nnp.set_printoptions(precision=8)\nQ = Q_continuous_white_noise(\n dim=3, dt=0.05, spectral_density=1)\nprint(Q)\nnp.set_printoptions(precision=3)\n```\n\n [[ 0.00000002 0.00000078 0.00002083]\n [ 0.00000078 0.00004167 0.00125 ]\n [ 0.00002083 0.00125 0.05 ]]\n\n\nWe can see that most of the terms are very small. Recall that the only equation using this matrix is\n\n$$ \\mathbf P=\\mathbf{FPF}^\\mathsf{T} + \\mathbf Q$$\n\nIf the values for $\\mathbf Q$ are small relative to $\\mathbf P$\nthan it will be contributing almost nothing to the computation of $\\mathbf P$. Setting $\\mathbf Q$ to the zero matrix except for the lower right term\n\n$$\\mathbf Q=\\begin{bmatrix}0&0&0\\\\0&0&0\\\\0&0&\\sigma^2\\end{bmatrix}$$\n\nwhile not correct, is often a useful approximation. If you do this for an important application you will have to perform quite a few studies to guarantee that your filter works in a variety of situations. \n\nIf you do this, 'lower right term' means the most rapidly changing term for each variable. If the state is $x=\\begin{bmatrix}x & \\dot x & \\ddot{x} & y & \\dot{y} & \\ddot{y}\\end{bmatrix}^\\mathsf{T}$ Then Q will be 6x6; the elements for both $\\ddot{x}$ and $\\ddot{y}$ will have to be set to non-zero in $\\mathbf Q$.\n\n## Numeric Integration of Differential Equations\n\nWe've been exposed to several numerical techniques to solve linear differential equations. These include state-space methods, the Laplace transform, and van Loan's method. \n\nThese work well for linear ordinary differential equations (ODEs), but do not work well for nonlinear equations. For example, consider trying to predict the position of a rapidly turning car. Cars maneuver by turning the front wheels. This makes them pivot around their rear axle as it moves forward. Therefore the path will be continuously varying and a linear prediction will necessarily produce an incorrect value. If the change in the system is small enough relative to $\\Delta t$ this can often produce adequate results, but that will rarely be the case with the nonlinear Kalman filters we will be studying in subsequent chapters. \n\nFor these reasons we need to know how to numerically integrate ODEs. This can be a vast topic that requires several books. If you need to explore this topic in depth *Computational Physics in Python* by Dr. Eric Ayars is excellent, and available for free here:\n\nhttp://phys.csuchico.edu/ayars/312/Handouts/comp-phys-python.pdf\n\nHowever, I will cover a few simple techniques which will work for a majority of the problems you encounter.\n\n\n### Euler's Method\n\nLet's say we have the initial condition problem of \n\n$$\\begin{gathered}\ny' = y, \\\\ y(0) = 1\n\\end{gathered}$$\n\nWe happen to know the exact answer is $y=e^t$ because we solved it earlier, but for an arbitrary ODE we will not know the exact solution. In general all we know is the derivative of the equation, which is equal to the slope. We also know the initial value: at $t=0$, $y=1$. If we know these two pieces of information we can predict the value at $y(t=1)$ using the slope at $t=0$ and the value of $y(0)$. I've plotted this below.\n\n\n```python\nimport matplotlib.pyplot as plt\nt = np.linspace(-1, 1, 10)\nplt.plot(t, np.exp(t))\nt = np.linspace(-1, 1, 2)\nplt.plot(t,t+1, ls='--', c='k');\n```\n\nYou can see that the slope is very close to the curve at $t=0.1$, but far from it\nat $t=1$. But let's continue with a step size of 1 for a moment. We can see that at $t=1$ the estimated value of $y$ is 2. Now we can compute the value at $t=2$ by taking the slope of the curve at $t=1$ and adding it to our initial estimate. The slope is computed with $y'=y$, so the slope is 2.\n\n\n```python\nimport kf_book.book_plots as book_plots\n\nt = np.linspace(-1, 2, 20)\nplt.plot(t, np.exp(t))\nt = np.linspace(0, 1, 2)\nplt.plot([1, 2, 4], ls='--', c='k')\nbook_plots.set_labels(x='x', y='y');\n```\n\nHere we see the next estimate for y is 4. The errors are getting large quickly, and you might be unimpressed. But 1 is a very large step size. Let's put this algorithm in code, and verify that it works by using a small step size.\n\n\n```python\ndef euler(t, tmax, y, dx, step=1.):\n ys = []\n while t < tmax:\n y = y + step*dx(t, y)\n ys.append(y)\n t +=step \n return ys\n```\n\n\n```python\ndef dx(t, y): return y\n\nprint(euler(0, 1, 1, dx, step=1.)[-1])\nprint(euler(0, 2, 1, dx, step=1.)[-1])\n```\n\n 2.0\n 4.0\n\n\nThis looks correct. So now let's plot the result of a much smaller step size.\n\n\n```python\nys = euler(0, 4, 1, dx, step=0.00001)\nplt.subplot(1,2,1)\nplt.title('Computed')\nplt.plot(np.linspace(0, 4, len(ys)),ys)\nplt.subplot(1,2,2)\nt = np.linspace(0, 4, 20)\nplt.title('Exact')\nplt.plot(t, np.exp(t));\n```\n\n\n```python\nprint('exact answer=', np.exp(4))\nprint('euler answer=', ys[-1])\nprint('difference =', np.exp(4) - ys[-1])\nprint('iterations =', len(ys))\n```\n\n exact answer= 54.5981500331\n euler answer= 54.59705808834125\n difference = 0.00109194480299\n iterations = 400000\n\n\nHere we see that the error is reasonably small, but it took a very large number of iterations to get three digits of precision. In practice Euler's method is too slow for most problems, and we use more sophisticated methods.\n\nBefore we go on, let's formally derive Euler's method, as it is the basis for the more advanced Runge Kutta methods used in the next section. In fact, Euler's method is the simplest form of Runge Kutta.\n\n\nHere are the first 3 terms of the Euler expansion of $y$. An infinite expansion would give an exact answer, so $O(h^4)$ denotes the error due to the finite expansion.\n\n$$y(t_0 + h) = y(t_0) + h y'(t_0) + \\frac{1}{2!}h^2 y''(t_0) + \\frac{1}{3!}h^3 y'''(t_0) + O(h^4)$$\n\nHere we can see that Euler's method is using the first two terms of the Taylor expansion. Each subsequent term is smaller than the previous terms, so we are assured that the estimate will not be too far off from the correct value. \n\n### Runge Kutta Methods\n\n\nRunge Kutta is the workhorse of numerical integration. There are a vast number of methods in the literature. In practice, using the Runge Kutta algorithm that I present here will solve most any problem you will face. It offers a very good balance of speed, precision, and stability, and it is the 'go to' numerical integration method unless you have a very good reason to choose something different.\n\nLet's dive in. We start with some differential equation\n\n$$\\ddot{y} = \\frac{d}{dt}\\dot{y}$$.\n\nWe can substitute the derivative of y with a function f, like so\n\n$$\\ddot{y} = \\frac{d}{dt}f(y,t)$$.\n\nDeriving these equations is outside the scope of this book, but the Runge Kutta RK4 method is defined with these equations.\n\n$$y(t+\\Delta t) = y(t) + \\frac{1}{6}(k_1 + 2k_2 + 2k_3 + k_4) + O(\\Delta t^4)$$\n\n$$\\begin{aligned}\nk_1 &= f(y,t)\\Delta t \\\\\nk_2 &= f(y+\\frac{1}{2}k_1, t+\\frac{1}{2}\\Delta t)\\Delta t \\\\\nk_3 &= f(y+\\frac{1}{2}k_2, t+\\frac{1}{2}\\Delta t)\\Delta t \\\\\nk_4 &= f(y+k_3, t+\\Delta t)\\Delta t\n\\end{aligned}\n$$\n\nHere is the corresponding code:\n\n\n```python\ndef runge_kutta4(y, x, dx, f):\n \"\"\"computes 4th order Runge-Kutta for dy/dx.\n y is the initial value for y\n x is the initial value for x\n dx is the difference in x (e.g. the time step)\n f is a callable function (y, x) that you supply \n to compute dy/dx for the specified values.\n \"\"\"\n \n k1 = dx * f(y, x)\n k2 = dx * f(y + 0.5*k1, x + 0.5*dx)\n k3 = dx * f(y + 0.5*k2, x + 0.5*dx)\n k4 = dx * f(y + k3, x + dx)\n \n return y + (k1 + 2*k2 + 2*k3 + k4) / 6.\n```\n\nLet's use this for a simple example. Let\n\n$$\\dot{y} = t\\sqrt{y(t)}$$\n\nwith the initial values\n\n$$\\begin{aligned}t_0 &= 0\\\\y_0 &= y(t_0) = 1\\end{aligned}$$\n\n\n```python\nimport math\nimport numpy as np\nt = 0.\ny = 1.\ndt = .1\n\nys, ts = [], []\n\ndef func(y,t):\n return t*math.sqrt(y)\n\nwhile t <= 10:\n y = runge_kutta4(y, t, dt, func)\n t += dt\n ys.append(y)\n ts.append(t)\n\nexact = [(t**2 + 4)**2 / 16. for t in ts]\nplt.plot(ts, ys)\nplt.plot(ts, exact)\n\nerror = np.array(exact) - np.array(ys)\nprint(\"max error {}\".format(max(error)))\n```\n\n## Bayesian Filtering\n\nStarting in the Discrete Bayes chapter I used a Bayesian formulation for filtering. Suppose we are tracking an object. We define its *state* at a specific time as its position, velocity, and so on. For example, we might write the state at time $t$ as $\\mathbf x_t = \\begin{bmatrix}x_t &\\dot x_t \\end{bmatrix}^\\mathsf T$. \n\nWhen we take a measurement of the object we are measuring the state or part of it. Sensors are noisy, so the measurement is corrupted with noise. Clearly though, the measurement is determined by the state. That is, a change in state may change the measurement, but a change in measurement will not change the state.\n\nIn filtering our goal is to compute an optimal estimate for a set of states $\\mathbf x_{0:t}$ from time 0 to time $t$. If we knew $\\mathbf x_{0:t}$ then it would be trivial to compute a set of measurements $\\mathbf z_{0:t}$ corresponding to those states. However, we receive a set of measurements $\\mathbf z_{0:t}$, and want to compute the corresponding states $\\mathbf x_{0:t}$. This is called *statistical inversion* because we are trying to compute the input from the output. \n\nInversion is a difficult problem because there is typically no unique solution. For a given set of states $\\mathbf x_{0:t}$ there is only one possible set of measurements (plus noise), but for a given set of measurements there are many different sets of states that could have led to those measurements. \n\nRecall Bayes Theorem:\n\n$$P(x \\mid z) = \\frac{P(z \\mid x)P(x)}{P(z)}$$\n\nwhere $P(z \\mid x)$ is the *likelihood* of the measurement $z$, $P(x)$ is the *prior* based on our process model, and $P(z)$ is a normalization constant. $P(x \\mid z)$ is the *posterior*, or the distribution after incorporating the measurement $z$, also called the *evidence*.\n\nThis is a *statistical inversion* as it goes from $P(z \\mid x)$ to $P(x \\mid z)$. The solution to our filtering problem can be expressed as:\n\n$$P(\\mathbf x_{0:t} \\mid \\mathbf z_{0:t}) = \\frac{P(\\mathbf z_{0:t} \\mid \\mathbf x_{0:t})P(\\mathbf x_{0:t})}{P(\\mathbf z_{0:t})}$$\n\nThat is all well and good until the next measurement $\\mathbf z_{t+1}$ comes in, at which point we need to recompute the entire expression for the range $0:t+1$. \n\n\nIn practice this is intractable because we are trying to compute the posterior distribution $P(\\mathbf x_{0:t} \\mid \\mathbf z_{0:t})$ for the state over the full range of time steps. But do we really care about the probability distribution at the third step (say) when we just received the tenth measurement? Not usually. So we relax our requirements and only compute the distributions for the current time step.\n\nThe first simplification is we describe our process (e.g., the motion model for a moving object) as a *Markov chain*. That is, we say that the current state is solely dependent on the previous state and a transition probability $P(\\mathbf x_k \\mid \\mathbf x_{k-1})$, which is just the probability of going from the last state to the current one. We write:\n\n$$\\mathbf x_k \\sim P(\\mathbf x_k \\mid \\mathbf x_{k-1})$$\n\nThe next simplification we make is do define the *measurement model* as depending on the current state $\\mathbf x_k$ with the conditional probability of the measurement given the current state: $P(\\mathbf z_t \\mid \\mathbf x_x)$. We write:\n\n$$\\mathbf z_k \\sim P(\\mathbf z_t \\mid \\mathbf x_x)$$\n\nWe have a recurrance now, so we need an initial condition to terminate it. Therefore we say that the initial distribution is the probablity of the state $\\mathbf x_0$:\n\n$$\\mathbf x_0 \\sim P(\\mathbf x_0)$$\n\n\nThese terms are plugged into Bayes equation. If we have the state $\\mathbf x_0$ and the first measurement we can estimate $P(\\mathbf x_1 | \\mathbf z_1)$. The motion model creates the prior $P(\\mathbf x_2 \\mid \\mathbf x_1)$. We feed this back into Bayes theorem to compute $P(\\mathbf x_2 | \\mathbf z_2)$. We continue this predictor-corrector algorithm, recursively computing the state and distribution at time $t$ based solely on the state and distribution at time $t-1$ and the measurement at time $t$.\n\nThe details of the mathematics for this computation varies based on the problem. The **Discrete Bayes** and **Univariate Kalman Filter** chapters gave two different formulations which you should have been able to reason through. The univariate Kalman filter assumes that for a scalar state both the noise and process are linear model are affected by zero-mean, uncorrelated Gaussian noise. \n\nThe Multivariate Kalman filter make the same assumption but for states and measurements that are vectors, not scalars. Dr. Kalman was able to prove that if these assumptions hold true then the Kalman filter is *optimal* in a least squares sense. Colloquially this means there is no way to derive more information from the noise. In the remainder of the book I will present filters that relax the constraints on linearity and Gaussian noise.\n\nBefore I go on, a few more words about statistical inversion. As Calvetti and Somersalo write in *Introduction to Bayesian Scientific Computing*, \"we adopt the Bayesian point of view: *randomness simply means lack of information*.\"[3] Our state parametize physical phenomena that we could in principle measure or compute: velocity, air drag, and so on. We lack enough information to compute or measure their value, so we opt to consider them as random variables. Strictly speaking they are not random, thus this is a subjective position. \n\nThey devote a full chapter to this topic. I can spare a paragraph. Bayesian filters are possible because we ascribe statistical properties to unknown parameters. In the case of the Kalman filter we have closed-form solutions to find an optimal estimate. Other filters, such as the discrete Bayes filter or the particle filter which we cover in a later chapter, model the probability in a more ad-hoc, non-optimal manner. The power of our technique comes from treating lack of information as a random variable, describing that random variable as a probability distribution, and then using Bayes Theorem to solve the statistical inference problem.\n\n## Converting Kalman Filter to a g-h Filter\n\nI've stated that the Kalman filter is a form of the g-h filter. It just takes some algebra to prove it. It's more straightforward to do with the one dimensional case, so I will do that. Recall \n\n$$\n\\mu_{x}=\\frac{\\sigma_1^2 \\mu_2 + \\sigma_2^2 \\mu_1} {\\sigma_1^2 + \\sigma_2^2}\n$$\n\nwhich I will make more friendly for our eyes as:\n\n$$\n\\mu_{x}=\\frac{ya + xb} {a+b}\n$$\n\nWe can easily put this into the g-h form with the following algebra\n\n$$\n\\begin{aligned}\n\\mu_{x}&=(x-x) + \\frac{ya + xb} {a+b} \\\\\n\\mu_{x}&=x-\\frac{a+b}{a+b}x + \\frac{ya + xb} {a+b} \\\\ \n\\mu_{x}&=x +\\frac{-x(a+b) + xb+ya}{a+b} \\\\\n\\mu_{x}&=x+ \\frac{-xa+ya}{a+b} \\\\\n\\mu_{x}&=x+ \\frac{a}{a+b}(y-x)\\\\\n\\end{aligned}\n$$\n\nWe are almost done, but recall that the variance of estimate is given by \n\n$$\\begin{aligned}\n\\sigma_{x}^2 &= \\frac{1}{\\frac{1}{\\sigma_1^2} + \\frac{1}{\\sigma_2^2}} \\\\\n&= \\frac{1}{\\frac{1}{a} + \\frac{1}{b}}\n\\end{aligned}$$\n\nWe can incorporate that term into our equation above by observing that\n\n$$ \n\\begin{aligned}\n\\frac{a}{a+b} &= \\frac{a/a}{(a+b)/a} = \\frac{1}{(a+b)/a} \\\\\n &= \\frac{1}{1 + \\frac{b}{a}} = \\frac{1}{\\frac{b}{b} + \\frac{b}{a}} \\\\\n &= \\frac{1}{b}\\frac{1}{\\frac{1}{b} + \\frac{1}{a}} \\\\\n &= \\frac{\\sigma^2_{x'}}{b}\n \\end{aligned}\n$$\n\nWe can tie all of this together with\n\n$$\n\\begin{aligned}\n\\mu_{x}&=x+ \\frac{a}{a+b}(y-x) \\\\\n&= x + \\frac{\\sigma^2_{x'}}{b}(y-x) \\\\\n&= x + g_n(y-x)\n\\end{aligned}\n$$\n\nwhere\n\n$$g_n = \\frac{\\sigma^2_{x}}{\\sigma^2_{y}}$$\n\nThe end result is multiplying the residual of the two measurements by a constant and adding to our previous value, which is the $g$ equation for the g-h filter. $g$ is the variance of the new estimate divided by the variance of the measurement. Of course in this case $g$ is not a constant as it varies with each time step as the variance changes. We can also derive the formula for $h$ in the same way. It is not a particularly illuminating derivation and I will skip it. The end result is\n\n$$h_n = \\frac{COV (x,\\dot x)}{\\sigma^2_{y}}$$\n\nThe takeaway point is that $g$ and $h$ are specified fully by the variance and covariances of the measurement and predictions at time $n$. In other words, we are picking a point between the measurement and prediction by a scale factor determined by the quality of each of those two inputs.\n\n## References\n\n * [1] C.B. Molwer and C.F. Van Loan \"Nineteen Dubious Ways to Compute the Exponential of a Matrix, Twenty-Five Years Later,\", *SIAM Review 45, 3-49*. 2003.\n\n\n * [2] C.F. van Loan, \"Computing Integrals Involving the Matrix Exponential,\" IEEE *Transactions Automatic Control*, June 1978.\n \n \n * [3] Calvetti, D and Somersalo E, \"Introduction to Bayesian Scientific Computing: Ten Lectures on Subjective Computing,\", *Springer*, 2007.\n", "meta": {"hexsha": "824f229069d3cd2417b98fd034b758f1e7b27a17", "size": 177070, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "07-Kalman-Filter-Math.ipynb", "max_stars_repo_name": "MichaelRW/Kalman_and_Bayesian_Filtering", "max_stars_repo_head_hexsha": "2e9394c7942872b155228ed7b21798527961282b", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2017-10-27T02:19:43.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-13T09:17:00.000Z", "max_issues_repo_path": "07-Kalman-Filter-Math.ipynb", "max_issues_repo_name": "MichaelRW/Kalman_and_Bayesian_Filtering", "max_issues_repo_head_hexsha": "2e9394c7942872b155228ed7b21798527961282b", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "07-Kalman-Filter-Math.ipynb", "max_forks_repo_name": "MichaelRW/Kalman_and_Bayesian_Filtering", "max_forks_repo_head_hexsha": "2e9394c7942872b155228ed7b21798527961282b", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2018-01-17T17:42:21.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-12T18:19:42.000Z", "avg_line_length": 99.4216732173, "max_line_length": 27064, "alphanum_fraction": 0.7784209635, "converted": true, "num_tokens": 16279, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49218813572079556, "lm_q2_score": 0.20434189993684584, "lm_q1q2_score": 0.10057465877956151}}
{"text": "```python\n%matplotlib inline\n```\n\n\nWord Embeddings: Encoding Lexical Semantics\n===========================================\n\nWord embeddings are dense vectors of real numbers, one per word in your\nvocabulary. In NLP, it is almost always the case that your features are\nwords! But how should you represent a word in a computer? You could\nstore its ascii character representation, but that only tells you what\nthe word *is*, it doesn't say much about what it *means* (you might be\nable to derive its part of speech from its affixes, or properties from\nits capitalization, but not much). Even more, in what sense could you\ncombine these representations? We often want dense outputs from our\nneural networks, where the inputs are $|V|$ dimensional, where\n$V$ is our vocabulary, but often the outputs are only a few\ndimensional (if we are only predicting a handful of labels, for\ninstance). How do we get from a massive dimensional space to a smaller\ndimensional space?\n\nHow about instead of ascii representations, we use a one-hot encoding?\nThat is, we represent the word $w$ by\n\n\\begin{align}\\overbrace{\\left[ 0, 0, \\dots, 1, \\dots, 0, 0 \\right]}^\\text{|V| elements}\\end{align}\n\nwhere the 1 is in a location unique to $w$. Any other word will\nhave a 1 in some other location, and a 0 everywhere else.\n\nThere is an enormous drawback to this representation, besides just how\nhuge it is. It basically treats all words as independent entities with\nno relation to each other. What we really want is some notion of\n*similarity* between words. Why? Let's see an example.\n\nSuppose we are building a language model. Suppose we have seen the\nsentences\n\n* The mathematician ran to the store.\n* The physicist ran to the store.\n* The mathematician solved the open problem.\n\nin our training data. Now suppose we get a new sentence never before\nseen in our training data:\n\n* The physicist solved the open problem.\n\nOur language model might do OK on this sentence, but wouldn't it be much\nbetter if we could use the following two facts:\n\n* We have seen mathematician and physicist in the same role in a sentence. Somehow they\n have a semantic relation.\n* We have seen mathematician in the same role in this new unseen sentence\n as we are now seeing physicist.\n\nand then infer that physicist is actually a good fit in the new unseen\nsentence? This is what we mean by a notion of similarity: we mean\n*semantic similarity*, not simply having similar orthographic\nrepresentations. It is a technique to combat the sparsity of linguistic\ndata, by connecting the dots between what we have seen and what we\nhaven't. This example of course relies on a fundamental linguistic\nassumption: that words appearing in similar contexts are related to each\nother semantically. This is called the `distributional\nhypothesis `__.\n\n\nGetting Dense Word Embeddings\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nHow can we solve this problem? That is, how could we actually encode\nsemantic similarity in words? Maybe we think up some semantic\nattributes. For example, we see that both mathematicians and physicists\ncan run, so maybe we give these words a high score for the \"is able to\nrun\" semantic attribute. Think of some other attributes, and imagine\nwhat you might score some common words on those attributes.\n\nIf each attribute is a dimension, then we might give each word a vector,\nlike this:\n\n\\begin{align}q_\\text{mathematician} = \\left[ \\overbrace{2.3}^\\text{can run},\n \\overbrace{9.4}^\\text{likes coffee}, \\overbrace{-5.5}^\\text{majored in Physics}, \\dots \\right]\\end{align}\n\n\\begin{align}q_\\text{physicist} = \\left[ \\overbrace{2.5}^\\text{can run},\n \\overbrace{9.1}^\\text{likes coffee}, \\overbrace{6.4}^\\text{majored in Physics}, \\dots \\right]\\end{align}\n\nThen we can get a measure of similarity between these words by doing:\n\n\\begin{align}\\text{Similarity}(\\text{physicist}, \\text{mathematician}) = q_\\text{physicist} \\cdot q_\\text{mathematician}\\end{align}\n\nAlthough it is more common to normalize by the lengths:\n\n\\begin{align}\\text{Similarity}(\\text{physicist}, \\text{mathematician}) = \\frac{q_\\text{physicist} \\cdot q_\\text{mathematician}}\n {\\| q_\\text{\\physicist} \\| \\| q_\\text{mathematician} \\|} = \\cos (\\phi)\\end{align}\n\nWhere $\\phi$ is the angle between the two vectors. That way,\nextremely similar words (words whose embeddings point in the same\ndirection) will have similarity 1. Extremely dissimilar words should\nhave similarity -1.\n\n\nYou can think of the sparse one-hot vectors from the beginning of this\nsection as a special case of these new vectors we have defined, where\neach word basically has similarity 0, and we gave each word some unique\nsemantic attribute. These new vectors are *dense*, which is to say their\nentries are (typically) non-zero.\n\nBut these new vectors are a big pain: you could think of thousands of\ndifferent semantic attributes that might be relevant to determining\nsimilarity, and how on earth would you set the values of the different\nattributes? Central to the idea of deep learning is that the neural\nnetwork learns representations of the features, rather than requiring\nthe programmer to design them herself. So why not just let the word\nembeddings be parameters in our model, and then be updated during\ntraining? This is exactly what we will do. We will have some *latent\nsemantic attributes* that the network can, in principle, learn. Note\nthat the word embeddings will probably not be interpretable. That is,\nalthough with our hand-crafted vectors above we can see that\nmathematicians and physicists are similar in that they both like coffee,\nif we allow a neural network to learn the embeddings and see that both\nmathematicians and physicists have a large value in the second\ndimension, it is not clear what that means. They are similar in some\nlatent semantic dimension, but this probably has no interpretation to\nus.\n\n\nIn summary, **word embeddings are a representation of the *semantics* of\na word, efficiently encoding semantic information that might be relevant\nto the task at hand**. You can embed other things too: part of speech\ntags, parse trees, anything! The idea of feature embeddings is central\nto the field.\n\n\nWord Embeddings in Pytorch\n~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nBefore we get to a worked example and an exercise, a few quick notes\nabout how to use embeddings in Pytorch and in deep learning programming\nin general. Similar to how we defined a unique index for each word when\nmaking one-hot vectors, we also need to define an index for each word\nwhen using embeddings. These will be keys into a lookup table. That is,\nembeddings are stored as a $|V| \\times D$ matrix, where $D$\nis the dimensionality of the embeddings, such that the word assigned\nindex $i$ has its embedding stored in the $i$'th row of the\nmatrix. In all of my code, the mapping from words to indices is a\ndictionary named word\\_to\\_ix.\n\nThe module that allows you to use embeddings is torch.nn.Embedding,\nwhich takes two arguments: the vocabulary size, and the dimensionality\nof the embeddings.\n\nTo index into this table, you must use torch.LongTensor (since the\nindices are integers, not floats).\n\n\n\n\n\n```python\n# Author: Robert Guthrie\n\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\n\ntorch.manual_seed(1)\n```\n\n\n\n\n \n\n\n\n\n```python\nword_to_ix = {\"hello\": 0, \"world\": 1}\nembeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings\nlookup_tensor = torch.tensor([word_to_ix[\"hello\"]], dtype=torch.long)\nhello_embed = embeds(lookup_tensor)\nprint(\"hello embedding: \", hello_embed)\n\nworld_tensor = torch.tensor([word_to_ix[\"world\"]], dtype=torch.long)\nworld_embed = embeds(world_tensor)\nprint(\"world embedding: \", world_embed)\n```\n\n hello embedding: tensor([[ 3.5870, -1.8313, 1.5987, -1.2770, 0.3255]], grad_fn=)\n world embedding: tensor([[-0.4791, 1.3790, 2.5286, 0.4107, -0.9880]], grad_fn=)\n\n\nAn Example: N-Gram Language Modeling\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nRecall that in an n-gram language model, given a sequence of words\n$w$, we want to compute\n\n\\begin{align}P(w_i | w_{i-1}, w_{i-2}, \\dots, w_{i-n+1} )\\end{align}\n\nWhere $w_i$ is the ith word of the sequence.\n\nIn this example, we will compute the loss function on some training\nexamples and update the parameters with backpropagation.\n\n\n\n\n\n```python\nCONTEXT_SIZE = 2\nEMBEDDING_DIM = 10\n# We will use Shakespeare Sonnet 2\ntest_sentence = \"\"\"When forty winters shall besiege thy brow,\nAnd dig deep trenches in thy beauty's field,\nThy youth's proud livery so gazed on now,\nWill be a totter'd weed of small worth held:\nThen being asked, where all thy beauty lies,\nWhere all the treasure of thy lusty days;\nTo say, within thine own deep sunken eyes,\nWere an all-eating shame, and thriftless praise.\nHow much more praise deserv'd thy beauty's use,\nIf thou couldst answer 'This fair child of mine\nShall sum my count, and make my old excuse,'\nProving his beauty by succession thine!\nThis were to be new made when thou art old,\nAnd see thy blood warm when thou feel'st it cold.\"\"\".split()\n# we should tokenize the input, but we will ignore that for now\n# build a list of tuples. Each tuple is ([ word_i-2, word_i-1 ], target word)\ntrigrams = [([test_sentence[i], test_sentence[i + 1]], test_sentence[i + 2])\n for i in range(len(test_sentence) - 2)]\n# print the first 3, just so you can see what they look like\nprint(\"triagrams: \", trigrams[:3])\n\n```\n\n next most probable word is: thy\n sorted probs: [['thy', -4.186922], ['art', -4.1922836], ['Thy', -4.248099], ['of', -4.2611537], ['To', -4.2630076], [\"feel'st\", -4.277316], ['shall', -4.311347], ['all-eating', -4.315796], ['trenches', -4.335431], ['winters', -4.3398404], ['weed', -4.344031], ['to', -4.3594456], ['an', -4.3658733], ['Then', -4.3755765], ['field,', -4.3875885], ['This', -4.4035196], ['cold.', -4.4039836], ['asked,', -4.413395], ['be', -4.4173007], ['when', -4.4187098], ['And', -4.420888], ['sunken', -4.435668], ['use,', -4.454238], ['eyes,', -4.4582515], ['new', -4.470178], ['livery', -4.4881845], ['fair', -4.48823], ['answer', -4.4896107], ['couldst', -4.494951], ['deep', -4.4967484], ['worth', -4.5047307], ['make', -4.5149193], ['thine!', -4.523828], ['and', -4.5316954], ['old', -4.541312], ['thou', -4.542433], [\"deserv'd\", -4.5449767], ['my', -4.5454288], ['Will', -4.546628], ['small', -4.558781], ['were', -4.560234], ['proud', -4.565142], [\"youth's\", -4.5692616], ['thine', -4.5696316], ['lusty', -4.575783], [\"excuse,'\", -4.5793695], ['sum', -4.587189], ['held:', -4.5924115], ['blood', -4.593034], ['child', -4.6025386], ['much', -4.6080484], ['mine', -4.6193256], ['on', -4.6253176], ['so', -4.6262584], ['gazed', -4.627983], ['a', -4.6304474], ['his', -4.634258], ['count,', -4.6342707], ['old,', -4.638082], ['days;', -4.6426125], ['thriftless', -4.6506767], ['Were', -4.6526656], ['in', -4.654818], [\"beauty's\", -4.656125], ['own', -4.6561947], ['all', -4.6609883], ['succession', -4.666073], ['more', -4.679204], [\"totter'd\", -4.6818657], ['within', -4.689345], [\"'This\", -4.7001176], ['besiege', -4.702865], ['praise', -4.7082815], ['the', -4.7130375], ['Proving', -4.7230167], ['shame,', -4.727713], ['brow,', -4.739775], ['where', -4.753501], ['praise.', -4.7548923], ['see', -4.755212], ['Where', -4.7792172], ['Shall', -4.7813163], ['forty', -4.7825603], ['How', -4.806548], ['treasure', -4.8108234], ['dig', -4.8125415], ['by', -4.825708], ['beauty', -4.8277187], ['it', -4.830165], ['being', -4.8485456], ['say,', -4.8581595], ['lies,', -4.8927193], ['When', -4.9533033], ['warm', -4.9603124], ['If', -4.9679556], ['now,', -4.976203], ['made', -4.985473]]\n\n\n\n```python\n\nvocab = set(test_sentence)\nword_to_ix = {word: i for i, word in enumerate(vocab)}\nprint(\"word_to_ix for When: \", word_to_ix['When'])\n```\n\n next most probable word is: thy\n sorted probs: [['thy', -4.186922], ['art', -4.1922836], ['Thy', -4.248099], ['of', -4.2611537], ['To', -4.2630076], [\"feel'st\", -4.277316], ['shall', -4.311347], ['all-eating', -4.315796], ['trenches', -4.335431], ['winters', -4.3398404], ['weed', -4.344031], ['to', -4.3594456], ['an', -4.3658733], ['Then', -4.3755765], ['field,', -4.3875885], ['This', -4.4035196], ['cold.', -4.4039836], ['asked,', -4.413395], ['be', -4.4173007], ['when', -4.4187098], ['And', -4.420888], ['sunken', -4.435668], ['use,', -4.454238], ['eyes,', -4.4582515], ['new', -4.470178], ['livery', -4.4881845], ['fair', -4.48823], ['answer', -4.4896107], ['couldst', -4.494951], ['deep', -4.4967484], ['worth', -4.5047307], ['make', -4.5149193], ['thine!', -4.523828], ['and', -4.5316954], ['old', -4.541312], ['thou', -4.542433], [\"deserv'd\", -4.5449767], ['my', -4.5454288], ['Will', -4.546628], ['small', -4.558781], ['were', -4.560234], ['proud', -4.565142], [\"youth's\", -4.5692616], ['thine', -4.5696316], ['lusty', -4.575783], [\"excuse,'\", -4.5793695], ['sum', -4.587189], ['held:', -4.5924115], ['blood', -4.593034], ['child', -4.6025386], ['much', -4.6080484], ['mine', -4.6193256], ['on', -4.6253176], ['so', -4.6262584], ['gazed', -4.627983], ['a', -4.6304474], ['his', -4.634258], ['count,', -4.6342707], ['old,', -4.638082], ['days;', -4.6426125], ['thriftless', -4.6506767], ['Were', -4.6526656], ['in', -4.654818], [\"beauty's\", -4.656125], ['own', -4.6561947], ['all', -4.6609883], ['succession', -4.666073], ['more', -4.679204], [\"totter'd\", -4.6818657], ['within', -4.689345], [\"'This\", -4.7001176], ['besiege', -4.702865], ['praise', -4.7082815], ['the', -4.7130375], ['Proving', -4.7230167], ['shame,', -4.727713], ['brow,', -4.739775], ['where', -4.753501], ['praise.', -4.7548923], ['see', -4.755212], ['Where', -4.7792172], ['Shall', -4.7813163], ['forty', -4.7825603], ['How', -4.806548], ['treasure', -4.8108234], ['dig', -4.8125415], ['by', -4.825708], ['beauty', -4.8277187], ['it', -4.830165], ['being', -4.8485456], ['say,', -4.8581595], ['lies,', -4.8927193], ['When', -4.9533033], ['warm', -4.9603124], ['If', -4.9679556], ['now,', -4.976203], ['made', -4.985473]]\n\n\n\n```python\n\n\nclass NGramLanguageModeler(nn.Module):\n\n def __init__(self, vocab_size, embedding_dim, context_size):\n super(NGramLanguageModeler, self).__init__()\n self.embeddings = nn.Embedding(vocab_size, embedding_dim)\n self.linear1 = nn.Linear(context_size * embedding_dim, 128)\n # returns probability of a new word (shows the probability for each \n # word in the vocabulary) after the two context words are given \n self.linear2 = nn.Linear(128, vocab_size)\n\n def forward(self, inputs):\n embeds = self.embeddings(inputs).view((1, -1))\n out = F.relu(self.linear1(embeds))\n out = self.linear2(out)\n log_probs = F.log_softmax(out, dim=1)\n return log_probs\n\n\nlosses = []\nloss_function = nn.NLLLoss()\nmodel = NGramLanguageModeler(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE)\noptimizer = optim.SGD(model.parameters(), lr=0.001)\n\nfor epoch in range(10):\n total_loss = 0\n for context, target in trigrams:\n\n # Step 1. Prepare the inputs to be passed to the model (i.e, turn the words\n # into integer indices and wrap them in tensors)\n context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\n\n # Step 2. Recall that torch *accumulates* gradients. Before passing in a\n # new instance, you need to zero out the gradients from the old\n # instance\n model.zero_grad()\n\n # Step 3. Run the forward pass, getting log probabilities over next\n # words\n log_probs = model(context_idxs)\n\n # Step 4. Compute your loss function. (Again, Torch wants the target\n # word wrapped in a tensor)\n loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))\n\n # Step 5. Do the backward pass and update the gradient\n loss.backward()\n optimizer.step()\n\n # Get the Python number from a 1-element Tensor by calling tensor.item()\n total_loss += loss.item()\n losses.append(total_loss)\nprint(losses) # The loss decreased every iteration over the training data!\n\n```\n\n next most probable word is: thy\n sorted probs: [['thy', -4.186922], ['art', -4.1922836], ['Thy', -4.248099], ['of', -4.2611537], ['To', -4.2630076], [\"feel'st\", -4.277316], ['shall', -4.311347], ['all-eating', -4.315796], ['trenches', -4.335431], ['winters', -4.3398404], ['weed', -4.344031], ['to', -4.3594456], ['an', -4.3658733], ['Then', -4.3755765], ['field,', -4.3875885], ['This', -4.4035196], ['cold.', -4.4039836], ['asked,', -4.413395], ['be', -4.4173007], ['when', -4.4187098], ['And', -4.420888], ['sunken', -4.435668], ['use,', -4.454238], ['eyes,', -4.4582515], ['new', -4.470178], ['livery', -4.4881845], ['fair', -4.48823], ['answer', -4.4896107], ['couldst', -4.494951], ['deep', -4.4967484], ['worth', -4.5047307], ['make', -4.5149193], ['thine!', -4.523828], ['and', -4.5316954], ['old', -4.541312], ['thou', -4.542433], [\"deserv'd\", -4.5449767], ['my', -4.5454288], ['Will', -4.546628], ['small', -4.558781], ['were', -4.560234], ['proud', -4.565142], [\"youth's\", -4.5692616], ['thine', -4.5696316], ['lusty', -4.575783], [\"excuse,'\", -4.5793695], ['sum', -4.587189], ['held:', -4.5924115], ['blood', -4.593034], ['child', -4.6025386], ['much', -4.6080484], ['mine', -4.6193256], ['on', -4.6253176], ['so', -4.6262584], ['gazed', -4.627983], ['a', -4.6304474], ['his', -4.634258], ['count,', -4.6342707], ['old,', -4.638082], ['days;', -4.6426125], ['thriftless', -4.6506767], ['Were', -4.6526656], ['in', -4.654818], [\"beauty's\", -4.656125], ['own', -4.6561947], ['all', -4.6609883], ['succession', -4.666073], ['more', -4.679204], [\"totter'd\", -4.6818657], ['within', -4.689345], [\"'This\", -4.7001176], ['besiege', -4.702865], ['praise', -4.7082815], ['the', -4.7130375], ['Proving', -4.7230167], ['shame,', -4.727713], ['brow,', -4.739775], ['where', -4.753501], ['praise.', -4.7548923], ['see', -4.755212], ['Where', -4.7792172], ['Shall', -4.7813163], ['forty', -4.7825603], ['How', -4.806548], ['treasure', -4.8108234], ['dig', -4.8125415], ['by', -4.825708], ['beauty', -4.8277187], ['it', -4.830165], ['being', -4.8485456], ['say,', -4.8581595], ['lies,', -4.8927193], ['When', -4.9533033], ['warm', -4.9603124], ['If', -4.9679556], ['now,', -4.976203], ['made', -4.985473]]\n\n\n\n```python\ncontext = ['When', 'forty']\ncontext_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\nlog_probs = model(context_idxs)\nmax_ix = torch.argmax(log_probs)\n# ix_to_word = {i: word for word, i in word_to_ix.items()}\n# print(\"ix_to_word: \", ix_to_word)\n# next_word = ix_to_word[max_ix.item()]\nlist_vocab = list(vocab)\nnext_word = list_vocab[max_ix]\nprint(\"next most probable word is: \", next_word)\n#print(\"log probs: \", log_probs)\nword_prob = []\nlog_probs_np = log_probs.detach().numpy().flatten()\n# print(\"log probs numpy: \", log_probs_np)\nfor i in range(len(vocab)):\n word_prob.append([list_vocab[i], log_probs_np[i]])\n \nsorted_probs = sorted(word_prob, key = lambda tup: tup[1], reverse=True)\nprint(\"sorted probs: \", sorted_probs)\n```\n\n next most probable word is: thy\n sorted probs: [['thy', -4.186922], ['art', -4.1922836], ['Thy', -4.248099], ['of', -4.2611537], ['To', -4.2630076], [\"feel'st\", -4.277316], ['shall', -4.311347], ['all-eating', -4.315796], ['trenches', -4.335431], ['winters', -4.3398404], ['weed', -4.344031], ['to', -4.3594456], ['an', -4.3658733], ['Then', -4.3755765], ['field,', -4.3875885], ['This', -4.4035196], ['cold.', -4.4039836], ['asked,', -4.413395], ['be', -4.4173007], ['when', -4.4187098], ['And', -4.420888], ['sunken', -4.435668], ['use,', -4.454238], ['eyes,', -4.4582515], ['new', -4.470178], ['livery', -4.4881845], ['fair', -4.48823], ['answer', -4.4896107], ['couldst', -4.494951], ['deep', -4.4967484], ['worth', -4.5047307], ['make', -4.5149193], ['thine!', -4.523828], ['and', -4.5316954], ['old', -4.541312], ['thou', -4.542433], [\"deserv'd\", -4.5449767], ['my', -4.5454288], ['Will', -4.546628], ['small', -4.558781], ['were', -4.560234], ['proud', -4.565142], [\"youth's\", -4.5692616], ['thine', -4.5696316], ['lusty', -4.575783], [\"excuse,'\", -4.5793695], ['sum', -4.587189], ['held:', -4.5924115], ['blood', -4.593034], ['child', -4.6025386], ['much', -4.6080484], ['mine', -4.6193256], ['on', -4.6253176], ['so', -4.6262584], ['gazed', -4.627983], ['a', -4.6304474], ['his', -4.634258], ['count,', -4.6342707], ['old,', -4.638082], ['days;', -4.6426125], ['thriftless', -4.6506767], ['Were', -4.6526656], ['in', -4.654818], [\"beauty's\", -4.656125], ['own', -4.6561947], ['all', -4.6609883], ['succession', -4.666073], ['more', -4.679204], [\"totter'd\", -4.6818657], ['within', -4.689345], [\"'This\", -4.7001176], ['besiege', -4.702865], ['praise', -4.7082815], ['the', -4.7130375], ['Proving', -4.7230167], ['shame,', -4.727713], ['brow,', -4.739775], ['where', -4.753501], ['praise.', -4.7548923], ['see', -4.755212], ['Where', -4.7792172], ['Shall', -4.7813163], ['forty', -4.7825603], ['How', -4.806548], ['treasure', -4.8108234], ['dig', -4.8125415], ['by', -4.825708], ['beauty', -4.8277187], ['it', -4.830165], ['being', -4.8485456], ['say,', -4.8581595], ['lies,', -4.8927193], ['When', -4.9533033], ['warm', -4.9603124], ['If', -4.9679556], ['now,', -4.976203], ['made', -4.985473]]\n\n\nExercise: Computing Word Embeddings: Continuous Bag-of-Words\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\nThe Continuous Bag-of-Words model (CBOW) is frequently used in NLP deep\nlearning. It is a model that tries to predict words given the context of\na few words before and a few words after the target word. This is\ndistinct from language modeling, since CBOW is not sequential and does\nnot have to be probabilistic. Typcially, CBOW is used to quickly train\nword embeddings, and these embeddings are used to initialize the\nembeddings of some more complicated model. Usually, this is referred to\nas *pretraining embeddings*. It almost always helps performance a couple\nof percent.\n\nThe CBOW model is as follows. Given a target word $w_i$ and an\n$N$ context window on each side, $w_{i-1}, \\dots, w_{i-N}$\nand $w_{i+1}, \\dots, w_{i+N}$, referring to all context words\ncollectively as $C$, CBOW tries to minimize\n\n\\begin{align}-\\log p(w_i | C) = -\\log \\text{Softmax}(A(\\sum_{w \\in C} q_w) + b)\\end{align}\n\nwhere $q_w$ is the embedding for word $w$.\n\nImplement this model in Pytorch by filling in the class below. Some\ntips:\n\n* Think about which parameters you need to define.\n* Make sure you know what shape each operation expects. Use .view() if you need to\n reshape.\n\n\n\n\n\n```python\nCONTEXT_SIZE = 2 # 2 words to the left, 2 to the right\nraw_text = \"\"\"We are about to study the idea of a computational process.\nComputational processes are abstract beings that inhabit computers.\nAs they evolve, processes manipulate other abstract things called data.\nThe evolution of a process is directed by a pattern of rules\ncalled a program. People create programs to direct processes. In effect,\nwe conjure the spirits of the computer with our spells.\"\"\".split()\n\n# By deriving a set from `raw_text`, we deduplicate the array\nvocab = set(raw_text)\nvocab_size = len(vocab)\n\nword_to_ix = {word: i for i, word in enumerate(vocab)}\ndata = []\nfor i in range(2, len(raw_text) - 2):\n context = [raw_text[i - 2], raw_text[i - 1],\n raw_text[i + 1], raw_text[i + 2]]\n target = raw_text[i]\n data.append((context, target))\nprint(data[:5])\n\n\n# here are some functions to help you make\n# the data ready for use by your module\ndef make_context_vector(context, word_to_ix):\n idxs = [word_to_ix[w] for w in context]\n return torch.tensor(idxs, dtype=torch.long)\n\n\nmake_context_vector(data[0][0], word_to_ix) # example\n\n\nclass CBOW(nn.Module):\n def __init__(self, vocab_size, embedding_dim, context_size):\n super(CBOW, self).__init__()\n self.embeddings = nn.Embedding(vocab_size, embedding_dim)\n self.linear1 = nn.Linear(context_size * embedding_dim, 128)\n # returns probability of a new word (shows the probability for each \n # word in the vocabulary) after the two context words are given \n self.linear2 = nn.Linear(128, vocab_size)\n\n def forward(self, inputs):\n embeds = self.embeddings(inputs).view((1, -1))\n out = F.relu(self.linear1(embeds))\n out = self.linear2(out)\n log_probs = F.log_softmax(out, dim=1)\n return log_probs\n\n\n# create your model and train. \n\nloss_function = nn.NLLLoss()\nmodel = CBOW(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE * 2)\noptimizer = optim.SGD(model.parameters(), lr=0.001)\n\nfor epoch in range(10):\n total_loss = 0\n for context, target in data:\n # Step 1. Prepare the inputs to be passed to the model (i.e, turn the words\n # into integer indices and wrap them in tensors)\n context_idxs = make_context_vector(context, word_to_ix)\n\n # Step 2. Recall that torch *accumulates* gradients. Before passing in a\n # new instance, you need to zero out the gradients from the old\n # instance\n model.zero_grad()\n\n # Step 3. Run the forward pass, getting log probabilities over next\n # words\n log_probs = model(context_idxs)\n\n # Step 4. Compute your loss function. (Again, Torch wants the target\n # word wrapped in a tensor)\n loss = loss_function(log_probs, torch.tensor([word_to_ix[target]],\n dtype=torch.long))\n\n # Step 5. Do the backward pass and update the gradient\n loss.backward()\n optimizer.step()\n\n # Get the Python number from a 1-element Tensor by calling tensor.item()\n total_loss += loss.item()\n losses.append(total_loss)\nprint(losses) # The loss decreased every iteration over the training data!\n\n```\n\n next most probable word is: spirits\n sorted probs: [['spirits', -3.571494], ['Computational', -3.6043441], ['our', -3.6446052], ['process', -3.6532173], ['called', -3.6619964], ['programs', -3.6627073], ['about', -3.6661139], ['of', -3.667089], ['spells.', -3.6754756], ['processes', -3.6888878], ['rules', -3.6935806], ['evolution', -3.6960344], ['other', -3.6961038], ['that', -3.7074409], ['conjure', -3.7213202], ['In', -3.7506506], ['is', -3.7588222], ['We', -3.7936354], ['data.', -3.799165], ['As', -3.8064919], ['direct', -3.8306112], ['a', -3.86346], ['process.', -3.8688204], ['idea', -3.8740613], ['beings', -3.8935022], ['by', -3.9167356], ['pattern', -3.9174557], ['to', -3.968558], ['with', -3.9687386], ['manipulate', -3.978693], ['study', -3.9860647], ['things', -3.9939542], ['program.', -4.0097456], ['the', -4.0122476], ['effect,', -4.073447], ['computers.', -4.0799565], ['processes.', -4.0821033], ['abstract', -4.0989685], ['directed', -4.116846], ['inhabit', -4.155322], ['evolve,', -4.1835294], ['they', -4.195596], ['computer', -4.21617], ['People', -4.222899], ['The', -4.2314906], ['create', -4.238188], ['computational', -4.278097], ['we', -4.2880874], ['are', -4.3646474]]\n\n\n\n```python\n\ncontext = ['We', 'are', 'to', 'study']\ncontext_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)\nlog_probs = model(context_idxs)\nmax_ix = torch.argmax(log_probs)\n# ix_to_word = {i: word for word, i in word_to_ix.items()}\n# print(\"ix_to_word: \", ix_to_word)\n# next_word = ix_to_word[max_ix.item()]\nlist_vocab = list(vocab)\nnext_word = list_vocab[max_ix]\nprint(\"next most probable word is: \", next_word)\n#print(\"log probs: \", log_probs)\nword_prob = []\nlog_probs_np = log_probs.detach().numpy().flatten()\n# print(\"log probs numpy: \", log_probs_np)\nfor i in range(len(vocab)):\n word_prob.append([list_vocab[i], log_probs_np[i]])\n \nsorted_probs = sorted(word_prob, key = lambda tup: tup[1], reverse=True)\nprint(\"sorted probs: \", sorted_probs)\n```\n\n next most probable word is: spirits\n sorted probs: [['spirits', -3.571494], ['Computational', -3.6043441], ['our', -3.6446052], ['process', -3.6532173], ['called', -3.6619964], ['programs', -3.6627073], ['about', -3.6661139], ['of', -3.667089], ['spells.', -3.6754756], ['processes', -3.6888878], ['rules', -3.6935806], ['evolution', -3.6960344], ['other', -3.6961038], ['that', -3.7074409], ['conjure', -3.7213202], ['In', -3.7506506], ['is', -3.7588222], ['We', -3.7936354], ['data.', -3.799165], ['As', -3.8064919], ['direct', -3.8306112], ['a', -3.86346], ['process.', -3.8688204], ['idea', -3.8740613], ['beings', -3.8935022], ['by', -3.9167356], ['pattern', -3.9174557], ['to', -3.968558], ['with', -3.9687386], ['manipulate', -3.978693], ['study', -3.9860647], ['things', -3.9939542], ['program.', -4.0097456], ['the', -4.0122476], ['effect,', -4.073447], ['computers.', -4.0799565], ['processes.', -4.0821033], ['abstract', -4.0989685], ['directed', -4.116846], ['inhabit', -4.155322], ['evolve,', -4.1835294], ['they', -4.195596], ['computer', -4.21617], ['People', -4.222899], ['The', -4.2314906], ['create', -4.238188], ['computational', -4.278097], ['we', -4.2880874], ['are', -4.3646474]]\n\n", "meta": {"hexsha": "dd1a87a2d77e2475556a75c0f136d06804160042", "size": 35394, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "pytorch_tutorials/nlp/word_embeddings_tutorial.ipynb", "max_stars_repo_name": "adam-dziedzic/time-series-ml", "max_stars_repo_head_hexsha": "81aaa27f1dd9ea3d7d62b661dac40cac6c1ef77a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-03-25T13:19:46.000Z", "max_stars_repo_stars_event_max_datetime": "2018-03-25T13:19:46.000Z", "max_issues_repo_path": "pytorch_tutorials/nlp/word_embeddings_tutorial.ipynb", "max_issues_repo_name": "adam-dziedzic/time-series-ml", "max_issues_repo_head_hexsha": "81aaa27f1dd9ea3d7d62b661dac40cac6c1ef77a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "pytorch_tutorials/nlp/word_embeddings_tutorial.ipynb", "max_forks_repo_name": "adam-dziedzic/time-series-ml", "max_forks_repo_head_hexsha": "81aaa27f1dd9ea3d7d62b661dac40cac6c1ef77a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 60.193877551, "max_line_length": 2228, "alphanum_fraction": 0.5823585919, "converted": true, "num_tokens": 9393, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014733397551624, "lm_q2_score": 0.23370636225126956, "lm_q1q2_score": 0.10052816865549984}}
{"text": "```python\n%pylab inline\n```\n\n Populating the interactive namespace from numpy and matplotlib\n\n\n c:\\users\\isomorphism\\appdata\\local\\programs\\python\\python36\\lib\\site-packages\\IPython\\core\\magics\\pylab.py:160: UserWarning: pylab import has clobbered these variables: ['f']\n `%matplotlib` prevents importing * from pylab and numpy\n \"\\n`%matplotlib` prevents importing * from pylab and numpy\"\n\n\n# Probability Theory\n\n## Week 1\n\n**Topics:** Random sampling, permutations, combinations.\n\n**Problems:** 3.1, 3.3, 3.4, 3.5, 3.6, additional problem set 1.\n\n### Random sampling\n\nTaking a random sample can be done in different ways:\n\n||With replacement|Without replacement|\n|---|---|---|\n|**With order**|$n^k$|$n!, \\quad k \\leq n$|\n|**Without order**|$\\begin{pmatrix}n+k-1\\\\k\\end{pmatrix}$|$\\begin{pmatrix}n\\\\k\\end{pmatrix}$|\n\nThis leads to four different cases which will be addressed seperately.\n\n### Permutations\n\nThe general formula for permutations is:\n\n$$ _nP_k = \\dfrac{n!}{(n-k)!}$$\n\n#### With replacement\n\n#### Without replacement\n\n### Combinations\n\nThe general formula for combinations is (which can also be written as the binomial coefficient):\n\n$$ _nC_k=\\dfrac{n!}{k!(n-k)!} = \\begin{pmatrix}n\\\\k\\end{pmatrix}$$\n\n#### With replacement\n\n#### Without replacement\n\n## Week 2\n\n**Topics**: Probability definitions, probability rules, grid chart.\n\n**Problems:** 3.7, 3.8, 3.10, additional problem set 2.\n\n### Probability definitions\n\n#### Probability experiment\n\nThere are different examples of probability experiments:\n\n1. One throw with a dice\n2. Two throws with a dice\n3. One throw with a coin\n4. Pulling two cards from a deck of cards\n\n#### Sample space\n\nThe sample space $\\Omega$ are all the possible outcomes for a probability experiment. For the above given examples this gives:\n\n1. $\\Omega=\\{1,2,3,4,5,6\\}$\n2. $\\Omega=\\{(a,b):a,b \\in \\{1,2,3,4,5,6\\}\\}$\n3. $\\Omega=\\{H,T\\}$\n4. $\\Omega=\\{(a,b):a,b \\in \\{1,\\ldots,52\\}\\}$\n\n#### Event\n\nAn event is a subset of $\\Omega$.\n\n1. Throwing an even number, $A=\\{2,4,6\\}$\n2. Throwing the same dices, $A=\\{(1,1),(2,2),\\ldots,(6,6)\\}$\n3. Throwing heads, $A=\\{H\\}$\n4. Picking a heart A ($HA$) and club 2 ($C2$), $A=\\{(HA,C2),(C2,HA)\\}$\n\n#### Elementary event\n\nAn elementary event $\\omega$ (also called atomic event) is exactly one element from $\\Omega$.\n\nFor example (1) all the elementary events are: $\\{1\\}$, $\\{2\\}$, $\\{3\\}$, $\\{4\\}$, $\\{5\\}$, $\\{6\\}$.\n\n#### Probability (axiomatic definition)\n\nFor the probability function $P$ the following three axioms hold:\n\n1. $P(S)=1$\n2. $0\\leq P(A) \\leq 1$\n3. $P(A \\cap B) = P(A)+P(B)-P(A \\cap B)$, where $P(A \\cap B) = 0$ if and only if $A \\cap B = \\emptyset$.\n\n#### Probability space\n\nA probability space consists of the following:\n\n1. A sample space $\\Omega$ which are all the possible outcomes for the experiment.\n2. A set of events, where each event is a set containing zero or more outcomes.\n3. The assigment of probabilities to the events; that is, a function $P$ from events to probabilities.\n\nWith this we can determine the probability for an event $A$:\n\n$$P(A) = \\dfrac{n_a}{n_\\Omega}$$\n\nWhere $n_a$ are the favorable outcomes and $n_\\Omega$ are all the possible outcomes.\n\n### Probability rules\n\nNow we establish a few rules for probabilites. Later on when we cover conditional probilities we will add a few more rules to the list.\n\n#### Sum rule\n\n$P(A \\cup B) = P(A)+P(B)-P(A \\cap B)$ where $P(A \\cap B) = 0$ if and only if $A \\cap B = \\emptyset$.\n\n#### Complement rule\n\nWe can define this as $P(A) + P(\\bar{A}) = P(S) = 1$. We use this to infer that $P(A) = 1-P(\\bar{A})$. This is particularly useful because most of the times it is a lot easier to figure out what $P(\\bar{A})$ is, and then use the complement rule to determine the probability of $P(A)$.\n\n### Grid chart\n\nA grid chart is useful to visualize conditions.\n\nFor example, suppose we want to throw $2$ dices, and we multiply the outcome. What is the probability that the result is greater than $20$?\n\n\n\nUsing the grid chart it is easy to see that:\n\n$$P(x>20) = \\frac{6}{6^2} = \\frac{1}{6}$$\n\n## Week 3\n\n**Topics:** Conditional probability, independence, product rule, sampling with replacement, sampling without replacement, probability tree.\n\n**Problems:** 3.2, 3.12, 3.13, 3.14, 3.15, 3.16, additional problem set 3.\n\n### Conditional probability\n\nA conditional probability gives more information about the possible outcome space, which is defined as:\n\n$$P(A|B) = \\dfrac{P(A \\cap B)}{P(B)} ,\\quad P(B)>0$$\n\n### Indepence\n\nIf $P(A|B)=P(A)$ then the events $A$ and $B$ are independent.\n\n### Product rule\n\nThe general product rule is:\n\n$$ P(A \\cap B) = P(A|B) \\cdot P(B) = P(B|A) \\cdot P(A) $$\n\nIn the case that $A$ and $B$ are independent, we use:\n\n$$ P(A \\cap B) = P(A) \\cdot P(B)$$\n\n### Probability rules\n\nWith the addition of above rules, we now have the following rules for probabilities:\n\n1. $P(\\Omega)=1$, sample space has a probability of 1.\n2. $P(\\emptyset)=0$, an empty set has a probability of 0.\n3. $P(A)=1-P(\\bar{A})$, complement rule.\n4. $P(A\\cup B)=P(A)+P(B)-P(A\\cap B)$, sum rule.\n5. $P(A\\cup B)=P(A)+P(B)$, if and only if $A\\cap B=\\emptyset$.\n6. $P(A\\cap B)=P(A|B)\\cdot P(B)$, product rule.\n7. $P(A\\cap B)=P(A)\\cdot P(B)$, if and only if $A$ and $B$ are independent.\n\n### Sampling with replacement\n\n### Sampling without replacement\n\n### Probability tree\n\n## Week 4\n\n**Topics:** Bayes' rule.\n\n**Problems:** 3.9, 3.11, 3.17 till 3.31.\n\n### Bayes' rule\n\n#### Inference\n\nWhen we have a cause and effect model where $A_i\\xrightarrow[P(B|A_i)]{\\text{cause-effect}}B$ is known, we can use Bayes' rule to infer $B\\xleftarrow[P(A_i|B)]{\\text{inference}}A_i$.\n\n**General case**\n\nThe general use case for Bayes rule is:\n\n$$ P(A|B) = \\dfrac{P(A) \\cdot P(B|A)}{P(A)\\cdot P(B|A) + P(\\bar{A})\\cdot P(B|\\bar{A})} $$\n\nWe can use this to infer $P(A|B)$ if only $P(B|A)$ is known.\n\n**Definition**\n\nBayes' rule is defined as:\n\n$$ P(A_i|B) = \\dfrac{P(A_i)\\cdot P(B|A_i)}{\\sum\\left[P(A_j)\\cdot P(B|A_j)\\right]}$$\n\nsuch that the following holds:\n\n1. $A_i \\cap A_j = \\emptyset $, the intersection must be disjunct.\n2. $\\cup A_i = \\Omega$, the union of $A$ is $\\Omega$.\n\n## Week 5\n\n**Topics:** Discrete stochastic variable, discrete probability function, cumulative distribution function, expected value, variance for a discrete stochastic variable.\n\n**Problems:** 4.1, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8\n\n### Stochastic variables\n\n**Definition**\n\nGiven a sample space $\\Omega$ and a function $\\underline{k}$ such that $\\underline{k}:\\Omega\\rightarrow\\mathbb{R}$. Where the range is $\\underline{R}_k \\subset \\mathbb{R}$. In this context $\\underline{k}$ is the stochastic variable (or probability variable). With the following two rules:\n\n1. $f(k) \\geq 0$ for $\\forall k$\n2. $\\sum f(k) = 1, \\quad \\left(\\sum\\limits_{k\\in\\underline{k}}(\\underline{k}=k)=1\\right)$\n\n**Example**\n\nGiven a probability experiment: throwing with a dice.\n\nWe define $\\underline{k}$ as the squared outcome of the throw. The mapping of the function $\\underline{k}$ is defined as:\n\n$$\\Omega=\\underbrace{\\{1,2,3,4,5,6\\}}_{\\text{domain}} \\xrightarrow{\\underline{k}} \\underbrace{\\{1,4,9,16,25,36\\}}_{\\text{range}} = \\underline{R}_k \\subset \\mathbb{R}$$\n\n### Discrete probability distribution\n\nThe probability distribution is defined as $f(k)=P(\\underline{k}=k)$ such that $k\\in\\underline{R}_k$. For the above given example this yields:\n\n$$ f(1)=P(\\underline{k}=1)=\\dfrac{1}{6} \\\\ f(4)=P(\\underline{k}=4)=\\dfrac{1}{6} \\\\ \\vdots \\\\ f(36)=P(\\underline{k}=36)=\\dfrac{1}{6}$$\n\n**Code**\n\n\n```python\ndef f(k):\n r = [1,4,9,16,25,36]\n if k in r: return 1/len(r)\n return 0\n```\n\nPlotting this function gives a pin bar graph with a vertical line at the value when there is a probability defined. All the other values are not defined because this is a discrete function.\n\n\n```python\npoints = np.arange(0,37,0.01)\nplot(points, [f(x) for x in points], c='b', lw=2);\n```\n\n### Cumulative distribution function\n\nThe cumulative distribution function $F(k)=P(\\underline{k}\\leq k)$ for the example above yields:\n\n$$ F(1)=P(\\underline{k}\\leq1)=\\dfrac{1}{6} \\\\ F(2)=P(\\underline{k}\\leq2)=\\dfrac{1}{6} \\\\ F(4)=P(\\underline{k}\\leq4)=\\dfrac{2}{6} \\\\ \\vdots \\\\ F(36)=P(\\underline{k}\\leq36)=\\dfrac{6}{6}=1$$\n\n**Code**\n\n\n```python\ndef F(k):\n x = 0\n r = [1,4,9,16,25,36]\n for i in r: \n if i <= k: x = i\n try: return (r.index(x)+1)/len(r)\n except: return 0\n```\n\nPlotting this function gives a staircase graph.\n\n\n```python\npoints = np.arange(-10,50,0.01)\nplot(points, [F(x) for x in points], c='b', lw=2);\n```\n\n### Expected value of a discrete stochastic variable\n\nThe expected value $E(\\underline{k})$ is the weighted arithmetic mean from descriptive statistics but altered for a stochastic variable.\n\n**Definition**\n\nThe formula for the expected value is:\n\n$$ E(\\underline{k})=\\sum\\limits_{k\\in\\underline{k}} k\\cdot P(\\underline{k}=k) $$\n\nNotice that we do not divide by the sum of values since that sum would equal 1, hence it's omitted.\n\n**Example**\n\nThe expected value for the example with a dice is:\n\n$$E(\\underline{k})=1 \\cdot \\dfrac{1}{6} + 4 \\cdot \\dfrac{1}{6} + 9 \\cdot \\dfrac{1}{6} + 16 \\cdot \\dfrac{1}{6} + 25 \\cdot \\dfrac{1}{6} + 36 \\cdot \\dfrac{1}{6} = \\dfrac{91}{6} = 15 \\dfrac{1}{6}$$\n\n**Code**\n\n\n```python\ndef E(r): \n return sum([x * 1/len(r) for x in r])\n```\n\nWe can use this to easily determine the expected value for any range of $\\underline{k}$ when there is a uniform distribution.\n\n\n```python\nexpected = E([1,4,9,16,25,36])\nexpected\n```\n\n\n\n\n 15.166666666666668\n\n\n\nPlotting $f(k)$, $F(k)$, and $E(\\underline{k})$ yields:\n\n\n```python\npoints = np.arange(0,50,0.01)\nplot(points, [f(x) for x in points], c='lightblue', lw=2);\nplot(points, [F(x) for x in points], c='b', lw=2);\nscatter(expected, F(expected), c='r', lw=4);\n```\n\n### Variance of a discrete stochastic variable\n\nThe variance $\\text{Var}(\\underline{k})$ is the variance from descriptive statistics but is altered for a discrete stochastic variable.\n\n\n**Definition**\n\nThe formula for the variance of a discrete stochastic variable is defined as:\n\n$$ \\text{Var}(\\underline{k}) = \\sum\\limits_{k\\in\\underline{k}}\\left(k-E(\\underline{k})\\right)^2\\cdot P(\\underline{k}=k_i) $$\n\nNotice that we do not divide by the sum of probabilities since that sum would equal 1, hence it's omitted.\n\n**Example**\n\nAn example for throwing a dice gives:\n\n$$\\text{Var}(\\underline{k})= \\left(1-\\dfrac{91}{6}\\right)^2 + \\left(4-\\dfrac{91}{6}\\right)^2 + \\ldots + \\left(36-\\dfrac{91}{6}\\right)^2 = 149.14$$\n\n**Standard deviation**\n\nWith the example given above, it is easy to determine the standard deviation, which is:\n\n$$\\sigma_{\\underline{k}} = \\sqrt{149.14} = 12.21$$\n\n**Alternative method**\n\nAn alternative (preferred) method to calculate the variance of a discrete stochastic variable is:\n\n$$\\text{Var}(\\underline{k})= E(\\underline{k}^2)-\\left[E(\\underline{k})\\right]^2$$\n\nProof:\n\nWe start with the definition:\n\n$$\\begin{align} &\\sum\\limits_{k\\in\\underline{k}}\\left(k-E(\\underline{k})\\right)^2 \\cdot P(\\underline{k}=k) \\\\ = &\\sum\\limits_{k\\in\\underline{k}}\\left(k^2 - 2k\\cdot E(\\underline{k})+\\left[E(\\underline{k})\\right]^2 \\right) \\cdot P(\\underline{k}=k) \\\\ = & \\underbrace{\\sum\\limits_{k\\in\\underline{k}}k^2\\cdot P(\\underline{k}=k)}_{\\text{def.}\\ E(\\underline{k}^2)}-2\\sum\\limits_{k\\in\\underline{k}}k\\cdot E(\\underline{k})\\cdot P(\\underline{k}=k)+\\sum\\limits_{k\\in\\underline{k}}\\left[E(\\underline{k})\\right]^2\\cdot P(\\underline{k}=k) \\\\ = &E(\\underline{k}^2) - 2\\cdot E(\\underline{k}) \\cdot \\underbrace{\\sum\\limits_{k\\in\\underline{k}} k \\cdot P(\\underline{k}=k)}_{\\text{def.}\\ E(\\underline{k})} + \\left[E(\\underline{k})\\right]^2 \\cdot \\underbrace{\\sum\\limits_{k\\in\\underline{k}} P(\\underline{k}=k)}_{1} \\\\ = &E(\\underline{k}^2)-2\\cdot E(\\underline{k})\\cdot E(\\underline{k})+\\left[E(\\underline{k})\\right]^2 \\\\ = & E(\\underline{k}^2) - \\left[E(\\underline{k})\\right]^2 \\end{align}$$\n\nWhich proves our formula.\n\n**Code**\n\n\n```python\ndef var(r):\n expected = E(r)\n return sum([(x-expected)**2*f(x) for x in r])\n```\n\n\n```python\nvar([1,4,9,16,25,36])\n```\n\n\n\n\n 149.13888888888886\n\n\n\n\n```python\ndef var2(r):\n return E([x**2 for x in r]-E(r)**2)\n```\n\n\n```python\nvar2([1,4,9,16,25,36])\n```\n\n\n\n\n 149.13888888888886\n\n\n\n\n```python\ndef stdev(r):\n return math.sqrt(var2(r))\n```\n\n\n```python\nstdev([1,4,9,16,25,36])\n```\n\n\n\n\n 12.212243401148244\n\n\n\n## Week 6\n\n**Topics:** Rules for expected value and variance, summing stochastic variables, multi-dimensional stochastic variables.\n\n**Problems:** 4.9 till 4.13, 4.20, 4.21, additional problem set 4.\n\n### Applying linear transformations\n\nWhen we apply a linear transformation of the form $\\underline{m}=\\alpha \\underline{k} + A$ to our values, there are a few rules that apply to the expected value and variance that will help us. Instead of recalculating the expected value and/or variance we can use the observations below.\n\n#### Multiplying with a scalar $\\alpha$\n\nWhen we multiply with a scalar $\\alpha$, the expected value will also change by that factor:\n\n$$E(\\underline{m}) = E(\\alpha\\underline{k})=\\alpha E(\\underline{k})$$\n\nIf we apply a scalar $\\alpha$ the variance will change with a factor $\\alpha^2$:\n\n$$\\text{Var}(\\underline{m})=\\text{Var}(\\alpha\\underline{k})=\\alpha^2\\text{Var}(\\underline{k})$$\n\nEven if a negative value for $\\alpha$ will be used, the standard deviation will remain positive, thus:\n\n$$\\sigma_{\\underline{m}}=\\sigma_{\\alpha\\underline{k}}=\\sqrt{\\alpha^2 \\text{Var}(\\underline{k})}=\\ |\\ \\alpha \\ |\\ \\sigma_\\underline{k}$$\n\n#### Adding a constant $A$\n\nWhen we add a constant to the outcomes the expected value will also change by that constant value:\n\n$$E(\\underline{y}) = E(\\underline{k} + A) = E(\\underline{x})+A$$\n\nIf we shift all the values over a constant value $A$, the variance will not be affected because the spread between the variables will remain the same. \n\n### Rules for expected value and variance\n\n\n\n#### Sum rule for expected values\n\nThe expected value of the sum is the sum of the expected values:\n\n$$ E(\\underline{k}_{sum}) = E(\\underline{k}_1) + E(\\underline{k}_2) $$\n\n#### Sum rule for variance\n\nThe variance of the sum is the sum of the variances:\n\n$$ \\text{Var}(\\underline{k}_{sum}) = \\text{Var}(\\underline{k}_1) + \\text{Var}(\\underline{k}_2) $$ \n\n### Multidimensional stochastic variables\n\nA multidimensional stochastic variable is defined as:\n\n$$\\begin{align} f(k)&=P(\\underline{k}=k),\\ \\text{any}\\ m) \\\\&=\\sum\\limits_j P(\\underline{k}=k, \\underline{m}=m_j)\\sum\\limits_jp_{kj} \\end{align}$$\n\n## Week 7\n\n### Populatiecorrelatiecoëfficiënt $\\rho$\n\nOm de populatiecorrelatiecoefficient van twee stochasten te berekenen volgen we de onderstaande stappen:\n\n1. Bereken $E(\\underline{x})$ en $E(\\underline{y})$.\n2. Bereken $E(\\underline{x}^2)$ en $E(\\underline{y}^2)$.\n3. Bereken $\\text{Var}(\\underline{x})$ and $\\text{Var}(\\underline{y})$.\n4. Bereken $E(\\underline{x}\\cdot\\underline{y})$.\n5. Bereken $\\text{Cov}(\\underline{x}, \\underline{y})$.\n6. Bereken $\\rho(\\underline{x}, \\underline{y})$.\n\nWaarbij $\\text{Cov}(\\underline{x},\\underline{y})$ is gedefinieerd als: \n\n$$ \\text{Cov}(\\underline{x},\\underline{y}) = \\sum\\limits_{i=1}^r\\sum\\limits_{j=1}^k(x_i-\\mu_\\underline{x})(y_j-\\mu_\\underline{y})\\cdot P(\\underline{x}=x_i \\land \\underline{y} = y_j)$$\n\nEn net als bij Beschrijvende Statistiek, is $\\rho$ gedefinieerd als:\n\n$$ \\rho = \\frac{ \\text{Cov}(\\underline{x}, \\underline{y}) }{\\sigma_\\underline{x} \\cdot \\sigma_\\underline{y}} $$\n\n### Simultane kansverdeling\n\n### Onderling onafhankelijk\n\nTwee stochasten zijn onderling onafhankelijk als:\n\n$$ P(\\underline{x}=x_i \\land \\underline{y}=y_i)=P(\\underline{x}=x_i)\\cdot P(\\underline{y}=y_i)$$\n\nvoor alle getallen paren $(x_i,y_i)$.\n\n\n```python\n\n```\n", "meta": {"hexsha": "29bb1a774a27b8e6a78c38000f53477cc984f7e1", "size": 50679, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Applied Math/Y1S2/.ipynb_checkpoints/Probability Theory-checkpoint.ipynb", "max_stars_repo_name": "darkeclipz/jupyter-notebooks", "max_stars_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2018-08-28T12:16:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-08-28T12:16:12.000Z", "max_issues_repo_path": "Applied Math/Y1S2/.ipynb_checkpoints/Probability Theory-checkpoint.ipynb", "max_issues_repo_name": "darkeclipz/jupyter-notebooks", "max_issues_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Applied Math/Y1S2/.ipynb_checkpoints/Probability Theory-checkpoint.ipynb", "max_forks_repo_name": "darkeclipz/jupyter-notebooks", "max_forks_repo_head_hexsha": "5de784244ad9db12cfacbbec3053b11f10456d7e", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 49.4912109375, "max_line_length": 8960, "alphanum_fraction": 0.7173385426, "converted": true, "num_tokens": 5040, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.29098086621490676, "lm_q2_score": 0.34510527095787247, "lm_q1q2_score": 0.10041903067865184}}
{"text": "```python\n# Erasmus+ ICCT project (2018-1-SI01-KA203-047081)\n\n# Toggle cell visibility\n\nfrom IPython.display import HTML\ntag = HTML('''\nToggle cell visibility here .''')\ndisplay(tag)\n\n# Hide the code completely\n\n# from IPython.display import HTML\n# tag = HTML('''''')\n# display(tag)\n```\n\n\n\nToggle cell visibility here .\n\n\n\n```python\n%matplotlib notebook\nimport numpy as np\nimport control as control\nimport matplotlib.pyplot as plt\nimport ipywidgets as widgets\nimport scipy.signal as signal\ncontinuous_update=False\n```\n\n## Risposta dei sistemi del primo ordine\n\nLa funzione di trasferimento del sistema del primo ordine selezionato è definita come\n\n\\begin{equation}\n \\frac{K_p}{\\tau_p s+1},\n\\end{equation}\n\ndove $K_p$ e $\\tau_p$ sono parametri del sistema.\n\nLa risposta del sistema dipende dal segnale di ingresso. In questo esempio vengono utilizzati la funzione gradino (trasformata di Laplace $\\frac{1}{s}$), la funzione impulso unitario (trasformata di Laplace $1$), la funzione rampa unitaria (trasformata di Laplace $\\frac{1}{s^2}$) e un segnale sinusoidale (trasformata di Laplace $\\frac{1}{s^2+1}$) come segnali di ingresso.\n\nIl grafico sottostante mostra il segnale di ingresso e il segnale di uscita corrispondente per i valori scelti dei parametri $K_p$ e $\\tau_p$.\n\n### Come usare questo notebook?\n\nTesta le diverse funzioni di ingresso (gradino, impulso, rampa e sinusoide). Sposta gli sliders per modificare i valori di $K_p$ e $\\tau_p$.\n\n\n```python\n# sinus, step, ramp, x^2, sqrt(x)\nfunctionSelect = widgets.ToggleButtons(\n options=[('gradino unitario', 0), ('impulso unitario', 1), ('rampa unitaria', 2), ('sinusoide', 3)],\n description='Seleziona: ')\n\nfig = plt.figure(num='Risposta del sistema del primo ordine')\nfig.set_size_inches((9.8, 3))\nfig.set_tight_layout(True)\nf1 = fig.add_subplot(1, 1, 1)\n\nf1.grid(which='both', axis='both', color='lightgray')\n\nf1.set_xlabel('$t$ [s]')\nf1.set_ylabel('input, output')\n\nf1.axhline(0,Color='black',linewidth=0.5)\nf1.axvline(0,Color='black',linewidth=0.5)\n\ninputf, = f1.plot([],[])\nresponsef, = f1.plot([],[])\narrowf, = f1.plot([],[])\n\nnum_samples=2041\n\ndef create_draw_functions(Kp,taup,index):\n t=np.linspace(-0.1,5,num_samples)\n\n num=[Kp]\n den=[taup,1]\n Wsys=control.tf(num,den)\n \n global inputf,responsef, arrowf\n \n if index==0:\n yin=np.zeros(2041)\n yin[40:num_samples]=1\n tnew=np.linspace(0,5,2001)\n tout,yout=control.step_response(Wsys, T=tnew)\n elif index==1:\n yin=signal.unit_impulse(2001, 0)\n tnew=np.linspace(0,5,2001)\n t=tnew\n tout,yout=control.impulse_response(Wsys,tnew,X0=0)\n elif index==2:\n yin=np.zeros(num_samples)\n yin[40:num_samples]=np.linspace(0,5,2001)\n tnew=np.linspace(0,5,2001)\n tout,yout,xx=control.forced_response(Wsys,tnew,yin[40:])\n elif index==3: \n yin=np.sin(np.linspace(0,30,2001))\n tnew=np.linspace(0,30,2001)\n t=tnew\n tout,yout,xx=control.forced_response(Wsys,tnew,yin)\n \n f1.lines.remove(inputf)\n f1.lines.remove(responsef)\n f1.lines.remove(arrowf)\n \n inputf, = f1.plot(t,yin,color='C0',label='input')\n responsef, = f1.plot(tout,yout,color='C1',label='output')\n\n if index == 1:\n arrowf, = f1.plot([-0.1,0,0.1],[0.95,1,0.95],color='C0')\n else:\n arrowf, = f1.plot([],[])\n \n \n f1.legend()\n \n f1.relim()\n f1.relim()\n f1.autoscale_view()\n f1.autoscale_view()\n \nKp_slider = widgets.FloatSlider(value=1, min=0, max=2, step=0.1, description='$K_p$',\n continuous_update=True, layout=widgets.Layout(width='auto', flex='5 5 auto'),readout_format='.1f')\n\ntaup_slider = widgets.FloatSlider(value=1, min=0, max=2, step=0.1, description='$\\\\tau_p$',\n continuous_update=True, layout=widgets.Layout(width='auto', flex='5 5 auto'),readout_format='.1f')\n\n\ninput_data = widgets.interactive_output(create_draw_functions, {'Kp':Kp_slider,\n 'taup':taup_slider,\n 'index':functionSelect})\n\ndef update_sliders(index):\n global x0_slider\n \n Kpval = [1,1,1,1]\n Kp_slider.value = Kpval[index]\n taupval = [1,1,1,1]\n taup_slider.value = taupval[index] \n \ninput_data2 = widgets.interactive_output(update_sliders, {'index':functionSelect})\n\ndisplay(functionSelect)\n\ndisplay(Kp_slider,taup_slider,input_data)\n\n# display(Markdown(\"The system can be represented as $f(x)=5$ for small excursions of x about x0.\"))\n```\n\n\n \n\n\n\n\n\n\n\n ToggleButtons(description='Seleziona: ', options=(('gradino unitario', 0), ('impulso unitario', 1), ('rampa un…\n\n\n\n FloatSlider(value=1.0, description='$K_p$', layout=Layout(flex='5 5 auto', width='auto'), max=2.0, readout_for…\n\n\n\n FloatSlider(value=1.0, description='$\\\\tau_p$', layout=Layout(flex='5 5 auto', width='auto'), max=2.0, readout…\n\n\n\n Output()\n\n", "meta": {"hexsha": "7aec4d13eb70ca9631ada55b45eb717db9f3d1ba", "size": 156303, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_it/examples/02/.ipynb_checkpoints/TD-11-Risposta-nel-tempo-di-un-sistema-del-primo-ordine-checkpoint.ipynb", "max_stars_repo_name": "ICCTerasmus/ICCT", "max_stars_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 6, "max_stars_repo_stars_event_min_datetime": "2021-05-22T18:42:14.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-03T14:10:22.000Z", "max_issues_repo_path": "ICCT_it/examples/02/TD-11-Risposta-nel-tempo-di-un-sistema-del-primo-ordine.ipynb", "max_issues_repo_name": "ICCTerasmus/ICCT", "max_issues_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "ICCT_it/examples/02/TD-11-Risposta-nel-tempo-di-un-sistema-del-primo-ordine.ipynb", "max_forks_repo_name": "ICCTerasmus/ICCT", "max_forks_repo_head_hexsha": "fcd56ab6b5fddc00f72521cc87accfdbec6068f6", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 2, "max_forks_repo_forks_event_min_datetime": "2021-05-24T11:40:09.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-29T16:36:18.000Z", "avg_line_length": 142.7424657534, "max_line_length": 111891, "alphanum_fraction": 0.8294786408, "converted": true, "num_tokens": 1551, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.37754066879814546, "lm_q2_score": 0.2658804730998169, "lm_q1q2_score": 0.10038069163447219}}
{"text": "# Computação Científica com Julia\n\n * Computação científica\n * Julia\n## Como são as coisas no IPT hoje?\n\n * Planilha eletrônica\n * Excel\n * Deus nos acuda!\n\n\n# Será que isso é o suficiente???\n\n * Como detectar erros em planilhas?\n * Como reutilizar cálculos já feitos?\n * Como fazer algo mais complexo?\n * Como fazer **gráficos decentes**?\n\n## O problema do Excel é mais um problema de cultura do que qualquer outra coisa!\n\n# O que eu quero dizer com cultura:\n\n * Modelagem matemática de problemas se resume ao que se fazia 100 anos atrás.\n * Pouco reaproveitamento \n * Pouco compartilhamento de trabalho já realizado\n * Endeusamento do que já funciona\n * Pouca discussão e ossificação do conhecimento\n \n## Exemplo do que já ocorreu no passado\n\n * Túnel de vento (tuninho) circa 1990 - Mestrado do Nilson\n * Algor - escoamento potencial\n * STAN5 (ou 7 de acordo com o Nilson)\n * Modelo em escala reduzida\n * Medição com fio quente\n\n# Minha opinião\n\n * Compreender o que ocorre numa bancada ou em um trabalho externo\n * Dar ao computador o seu lugar de direito: um escravo muito burro mas muito forte!\n * Muito do que nós fazemaos é software. **Engenharia de Software**\n * Conhecer o que se faz aqui dentro e fora\n * Compartilhar este conhecimento\n\n# Ideal\n\n * Todas as bancadas modeladas\n * Modelos hidráulicos **e**\n * Modelos CFD\n * Conhecimento profundo do que ocorre de fato nas bancadas.\n * Um modelo das plantas em campo **antes** de medir.\n * Cada área ter um conjunto de ferramentas bem conhecidas \n * Ser \"piloto\" de software não vai nos levar longe \n\n\n# Computação Científica\n\n * Métodos básicos \n * Sistemas lineares\n * Aproximação\n * Equações diferenciais\n * Sistemas não lineares\n * Mais importante do que o básico, é saber como usar isso.\n\n * Métodos numérico rápidos e eficientes\n * Muito trabalhoso\n * Muito difícil\n * Coisa de profissa. \n\n# Porque Julia\n\n1. Ambiente interativo\n * Muito melhor que FORTRAN ou C/C++/Pascal/Java\n * Parecido com R/Python/Matlab/Mathematica/Scilab\n2. Desempenho\n * Consegue desempenho de C/FORTRAN\n * Mas não precisa vetorizar\n * Praticamente tudo é implementado em Julia!\n3. Biblioteca extensa\n * Visualização, Álgebra Linear, equações diferenciais, etc\n * Ainda não tem tudo o que Matlab tem\n * Muito fácil chamar Python (que hoje tem um ecossistema impressionante)\n4. A linguagem é muito boa!\n\n \n\n# Engenharia de Software\n\n * Controle de versões e repositórios de software (git e github)\n * Documentação no código (*literate programming*)\n * Testes unitários\n * Pensar no ambiente de trabalho:\n * Editor\n * Interface Notebook - Jupyter\n * REPL (terminal)\n * *Muito do que nós fazemos é programação exploratória*\n\n# Estrutura do curso\n\nObjetivo final:\n$$\n\\nabla\\cdot\\pmb{u} = 0\\\\\n\\frac{\\partial \\pmb{u}}{\\partial t} + \\pmb{u}\\cdot\\nabla\\pmb{u} = \n-\\nabla p + \\frac{1}{Re}\\nabla^2\\pmb{u}\n$$\n\nPrecisamos saber resolver este tipo de equação:\n$$\n\\nabla^2 \\phi = f\\\\\n\\frac{\\partial \\phi}{\\partial t} = \\alpha\\nabla^2 \n\\phi\\\\\n\\pmb{u}\\cdot\\phi = \\alpha\\nabla^2\\phi\n$$\n\nVamos focar no problema 1D para depois tentar avançar em outras direções\n\n# Em paralelo: use algum software para resolver um problema concreto:\n \n * [OpenFoam](https://www.openfoam.com/)\n * [SU2](https://su2code.github.io/)\n * [CalculiX](http://www.calculix.de/)\n * [Code Saturne](https://www.code-saturne.org/)\n * [Code Aster](https://www.code-aster.org/)\n * [Fenics](https://fenicsproject.org/)\n * [FreeFem++](https://freefem.org/)\n * [Dedalus Project](http://dedalus-project.org/)\n * [Nektar](https://www.nektar.info/)\n * [MEEP](https://meep.readthedocs.io/en/latest/)\n\n# Roteiro para $\\nabla^2 u = f$\n\n * $u^\\delta(x) = \\sum \\hat{u}_k \\phi_k(x) \\approx u(x)$ - Aproximação e interpolação\n * $\\nabla^2 u^\\delta - f = \\varepsilon(x)$ - Erro da equação diferencial\n * Resíduos ponderados $\\int_\\Omega w_i(x) \\nabla^2 u^\\delta \\:dx = \\int_\\Omega f w_i(x)\\:dx$\n * Formulação fraca: $ -\\int_\\Omega \\nabla w_i(x) \\cdot \\nabla u^\\delta \\:dx + \\int_{\\partial\\Omega} w_i\\frac{\\partial u}{\\partial n} = \\int_\\Omega f w_i(x)\\:dx$\n * Galerkin: $w_i(x) = \\phi_i(x)$\n * Sistema linear: $\\left[A\\right]\\cdot\\left\\{\\hat{u}\\right\\} = \\left\\{f\\right\\}$, \n $$A_{i,k} = -\\int_\\Omega\\nabla\\phi_i\\cdot\\nabla\\phi_k\\:dx + \\int_{\\partial\\Omega}\\phi_i\\frac{\\partial u}{\\partial n}\\\\\n f_i = \\int_\\Omega f\\phi_i\\:dx\n $$\n\n# Problema 1D\n\n 1. Interpolação e aproximação: polinomial, senos e cossenos\n 2. Derivadas: simbólica, numérica, diferenciação automática\n 3. Quadratura, Simbólica, Numérica\n 4. Sistemas lineares: Métodos diretos, métodos iterativos, *Explorar a estrutura da matriz*\n 5. Equações diferenciais ordinárias: problemas de valor inicial\n 6. Sistemas de equações não lineares: Newton-Raphson e outros\n\n\n# Introduzindo Julia\n\n * http://julialang.org\n * Lista de discussão https://discourse.julialang.org/\n * Canal do youtube https://www.youtube.com/user/JuliaLanguage\n * Documentação: https://docs.julialang.org\n\n\n```julia\n# Caluladora\n1+1\n\n```\n\n\n```julia\nfunction soma(a,b) \n return a+b\nend\nsoma2(a,b) = a+2b\n\nx = 1\ny = 10\nsoma2(x,y)\n```\n\n# Porque Julia consegue ser rápido como C?\n\n\n```julia\ncode_native(soma2, (Int,Int))\n```\n\n\n```julia\ncode_native(soma2, (Float64,Float64))\n```\n\n\n```julia\nusing ForwardDiff\n\nfunction f1(x)\n \n res = one(x)\n for i = 1:5\n res = x + res*x\n end\n return res\nend\ndf1 = x -> ForwardDiff.derivative(f1, x)\nf1b(x) = x + x*(one(x) + x*(one(x) + x * (one(x)+ 2x)))\ndf1b(x) = one(x) + 2x + 3x^2 + 4x^3 + 10x^4\n\n```\n\n\n```julia\ndf1(0.5) - df1b(0.5)\n```\n\n\n```julia\nusing BenchmarkTools\n\n@btime f1(0.5)\n@btime f1b(0.6)\n@btime df1(0.7)\n@btime df1b(0.7)\n```\n\n# Sistema de equações diferenciais ordinárias:\n\nEquações de Lorenz\n$$\n\\begin{align}\n\\frac{dx}{dt} &= σ(y-x) \\\\\n\\frac{dy}{dt} &= x(ρ-z) - y \\\\\n\\frac{dz}{dt} &= xy - βz \\\\\n\\end{align}\n$$\n\n\n```julia\nusing DifferentialEquations\nusing Plots\ngr()\n```\n\n\n```julia\nfunction lorenz(du,u,p,t)\n du[1] = 10.0*(u[2]-u[1])\n du[2] = u[1]*(28.0-u[3]) - u[2]\n du[3] = u[1]*u[2] - (8/3)*u[3]\nend\n```\n\n\n```julia\nu0 = [1.0;0.0;0.0]\ntspan = (0.0,100.0)\nprob = ODEProblem(lorenz,u0,tspan)\nsol = solve(prob);\n```\n\n\n```julia\ngr()\nplot(sol,vars=(1,2,3))\n```\n\n\n```julia\nusing Psychro\nusing Unitful\n```\n\n\n```julia\nprintln(volume(MoistAir, 20.0u\"°C\", DewPoint, 60.0u\"°F\", 1.0u\"atm\", u\"cm^3/lb\"))\nprintln(wetbulb(MoistAir, 20.0u\"°C\", DewPoint, 60.0u\"°F\", 1.0u\"atm\"))\nprintln(relhum(MoistAir, 20.0u\"°C\", DewPoint, 60.0u\"°F\", 1.0u\"atm\"))\n\n```\n\n\n```julia\nusing ACME\n\ncirc = @circuit begin\n j_in = voltagesource(), [-] ⟷ gnd\n r1 = resistor(1e3), [1] ⟷ j_in[+]\n c1 = capacitor(47e-9), [1] ⟷ r1[2], [2] ⟷ gnd\n d1 = diode(is=1e-15), [+] ⟷ r1[2], [-] ⟷ gnd\n d2 = diode(is=1.8e-15), [+] ⟷ gnd, [-] ⟷ r1[2]\n j_out = voltageprobe(), [+] ⟷ r1[2], [-] ⟷ gnd\nend\nmodel = DiscreteModel(circ, 1/4410)\nt = 1/44100 * (0:44099)'\ny = run!(model, sin.(2π*100 .* t));\nplot(t[1,:],y[1,:])\n```\n\n\n```julia\nusing PyCall\n```\n\n\n```julia\nmath = pyimport(\"math\")\nprintln(math.sin(1))\n\nnp = pyimport(\"numpy\")\nnprand = pyimport(\"numpy.random\")\nnprand.randn(3,4)\n\n```\n\n\n```julia\nusing LinearAlgebra, SpecialFunctions, Plots, ApproxFun\nx = Fun(identity,0..10)\nf = sin(x^2)\ng = cos(x)\n```\n\n\n```julia\nh = f + g^2\nr = roots(h)\nrp = roots(h')\n\nusing Plots\nplot(h)\nscatter!(r,h.(r))\nscatter!(rp,h.(rp))\n```\n", "meta": {"hexsha": "7b7052ab9417576ac65799dc9b223941a11e840b", "size": 14167, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "apresent.ipynb", "max_stars_repo_name": "iptscicomp/aulas", "max_stars_repo_head_hexsha": "41a5ac19dcf4e16118f0e5ecf9b389353e8de347", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "apresent.ipynb", "max_issues_repo_name": "iptscicomp/aulas", "max_issues_repo_head_hexsha": "41a5ac19dcf4e16118f0e5ecf9b389353e8de347", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "apresent.ipynb", "max_forks_repo_name": "iptscicomp/aulas", "max_forks_repo_head_hexsha": "41a5ac19dcf4e16118f0e5ecf9b389353e8de347", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2019-03-15T04:10:15.000Z", "max_forks_repo_forks_event_max_datetime": "2019-03-15T04:10:15.000Z", "avg_line_length": 24.2585616438, "max_line_length": 186, "alphanum_fraction": 0.5075880568, "converted": true, "num_tokens": 2672, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3486451353339457, "lm_q2_score": 0.2877678218692626, "lm_q1q2_score": 0.10032885120036383}}
{"text": "# Recording of class\nBackground: people join from Americas/East Asia\n\nSolution: recording of class\n- Will be put on secret youtube links - not searchable\n- Delete mid June\n\nConsent: via poll\n\n\n# Session 5:\n## Growing Causal Trees \n### - *Causal Forests and Generalized Random Forests*\n\n*Andreas Bjerre-Nielsen*\n\n## Agenda\n\n1. [Causality](#Causality)\n1. [Potential outcomes](#Potential-outcomes)\n2. [Experiments](#Experiments)\n3. [Matching](#Matching)\n - [Covariate based matching](#Covariate-matching)\n - [Propensity score matching](#Propensity-score-matching)\n \n4. [Heterogeneous treatment effects with causal trees](#Causal-trees)\n - [Causal Forest](#Causal-Forest)\n - [Generalized Random Forest](#Generalized-Random-Forest) \n - [Application of causal forest](#Application-of-causal-forest)\n\n\n# Buckle up... \n\n\n```python\nimport matplotlib.pyplot as plt\nimport networkx as nx\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\n%matplotlib inline\n```\n\n# Causality\n\n\n\n## Correlation does not imply causation\n\nSpurious or causal?\n\n\n\n\n\n## Getting predicted treatment effects for x range\n\n\n```python\nn_plot = 1000\nX_range = np.zeros([n_plot,p])\nX_range[:,0] = np.linspace(-2,2,n_plot)\nY_dgp = np.max([X_range[:, 0] * np.ones(n_plot), np.zeros(n_plot)],0) + X_range[:, 1] + np.max([X_range[:, 2] * np.ones(n_plot), np.zeros(n_plot)],0)\n\ntau_hat = est.effect(X_range, T0=t0, T1=t1)\ntau_lb, tau_ub = est.effect_interval(X_range, T0=t0, T1=t1, alpha=0.05)\n```\n\n## Plotting treatment effects\n\n\n```python\nfrom matplotlib import pyplot as plt\n%matplotlib inline\nf,ax = plt.subplots(figsize=(8,6))\nax.plot(X_range[:,0], Y_dgp, color='red', label='Data Generating Process')\n# plt.plot(X_range[:,0], tau_hat)\nax.fill_between(X_range[:,0], tau_lb, tau_ub, label=\"Causal Forest 95% CI\")\nax.legend()\n```\n\n# Comparison \n### Causal Forests and Generalized Random Forests\n\n## Causal Trees and Forests\nStrong econometric properties\n- unbiased and consistent (trees and forests)\n- asymptotic normality given $x$ (forests)\n\n- weaknesses: \n - either unconfounding or heterogeneity\n - we \"use\" data to buy honesty at the price of statistical power\n \n\n## Generalized Random Forest \nDifference from Causal Forest - trees are used for constructing weights!\n- strengths: \n - unconfounding (propensity) *AND* heterogeneity\n - additional uses \n - quantile regression\n - instrumental variables \n - clustered standard errors\n - and more\n- weakness: \n - we \"waste\" data on honesty\n", "meta": {"hexsha": "8f0f71ef1d572dad698ceac5921d61fa0246aef8", "size": 149561, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "session_5/lecture_5.ipynb", "max_stars_repo_name": "carolineespegren/mle_phd_oslo", "max_stars_repo_head_hexsha": "0b74203553cd4dd841a0186c999d3dfc59722000", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 5, "max_stars_repo_stars_event_min_datetime": "2021-05-26T19:42:00.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-17T07:10:56.000Z", "max_issues_repo_path": "session_5/lecture_5.ipynb", "max_issues_repo_name": "carolineespegren/mle_phd_oslo", "max_issues_repo_head_hexsha": "0b74203553cd4dd841a0186c999d3dfc59722000", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "session_5/lecture_5.ipynb", "max_forks_repo_name": "carolineespegren/mle_phd_oslo", "max_forks_repo_head_hexsha": "0b74203553cd4dd841a0186c999d3dfc59722000", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 10, "max_forks_repo_forks_event_min_datetime": "2021-05-04T12:31:35.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-15T06:26:24.000Z", "avg_line_length": 70.7813535258, "max_line_length": 26496, "alphanum_fraction": 0.8122304611, "converted": true, "num_tokens": 7893, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.20181322226037882, "lm_q1q2_score": 0.10011829426901715}}
![Wikimedia.org](\"https://upload.wikimedia.org/wikipedia/commons/0/00/Newton_method.png\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Decay_Chain_Thorium.svg#/media/File:Decay_Chain_Thorium.svg\"){kind=link}