| Software | Version |
|---|---|
| Python | 3.5.2 64bit [MSC v.1900 64 bit (AMD64)] |
| IPython | 5.1.0 |
| OS | Windows 10 10.0.10586 SP0 |
| numpy | 1.11.1 |
| scipy | 0.18.0 |
| matplotlib | 1.5.3 |
| sympy | 1.0 |
| pandas | 0.18.1 |
| ipython | 5.1.0 |
| jupyter | 1.0.0 |
| Thu Sep 22 01:04:43 2016 E. South America Standard Time | |
\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___some markdown 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$$ y = ax + b $$\n\n$$ ax^2 + bx + c = 0 $$\n\n$$ x_{1,2}= \\frac{-b \\pm\\sqrt{b^2 - 4ac}}{2a} $$\n\n\\begin{equation}\nf(x)|_{x=a} = f(a) + f\\prime(a)(x-a) + \\frac{f^n(a)}{2!}(x-a)^2 + ... + \\frac{f^n(a)}{n!}(x-a)^n + ...\n\\end{equation}\n\n\\begin{equation}\n(x + y)^n = {n\\choose 0}x^ny^0 + {n\\choose 1}x^{n-1}y^1 + ... + {n\\choose n}x^0y^n = \\sum_{k=0}^{n} {n\\choose k}x^{n-k}y^k\n\\end{equation}\n\n\\begin{equation}\n\\int_{-\\infty}^{+\\infty} e^{-x^2}dx = \\sqrt{\\pi}\n\\end{equation}\n\n\\begin{equation}\n\\left( \\begin{array}{ccc}\n2 & 1 & 3 \\\\\n2 & 6 & 8 \\\\\n6 & 8 & 18 \\end{array} \\right)\n\\end{equation}\n\n\\begin{equation}\nA = \\begin{pmatrix} \n a_{11} & a_{12} & \\dots & a_{1n} \\\\ \n a_{21} & a_{22} & \\dots & a_{2n} \\\\ \n \\vdots & \\vdots & \\ddots & \\vdots \\\\\n a_{m1} & a_{m1} & \\dots & a_{mn} \n \\end{pmatrix}\n\\end{equation}\n\n
Write your formulas here.
\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\nx = sympy.symbols('x')\na, b, c = sympy.symbols('a b c')\n\nsympy.solve(a * x**2 + b * x + c)\n\nsympy.init_printing()\n\na = 5\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 if a == 0:\n if b == 0:\n return math.nan\n elif c == 0:\n return b\n else:\n return -c / b\n else:\n d = b**2-4*a*c\n answer = []\n if d > 0:\n answer.append((-b - math.sqrt(d)) / (2*a))\n answer.append((-b + math.sqrt(d)) / (2*a))\n elif d == 0:\n answer.append(-b / (2*a))\n return answer\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(-3, 5, 1000)\ny = 2 * x + 3\nplt.plot(x, y)\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\nx = np.linspace(-3, 5, 1000)\ny = 2 * x + 3\nplt.plot(x, y)\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)\nplt.show()\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$$ ln(y) = ln(a e^{bx}) $$\n\n$$ ln(y) = ln(a) + ln(e^{bx}) $$\n\n$$ ln(y) = ln(a) + bx $$\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 plot_math_function(f, min_x, max_x, num_points):\n xpts = np.linspace(min_x, max_x, num_points) \n plt.plot(xpts, [f(x) for x in xpts])\n ax = plt.gca()\n ax.spines[\"bottom\"].set_position(\"zero\")\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n plt.show()\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 xpts = np.linspace(min_x, max_x, num_points) \n vectorized_fs = [np.vectorize(f) for f in functions]\n ys = [vectorized_f(xpts) for vectorized_f in vectorized_fs]\n for f in ys:\n plt.plot(xpts, f)\n ax = plt.gca()\n ax.spines[\"bottom\"].set_position(\"zero\")\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n plt.show()\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\ndef plot_math_functions(min_x, max_x, num_points): \n xpts = np.linspace(min_x, max_x)\n plt.plot(xpts, np.arcsin(xpts))\n plt.plot(xpts, np.arccos(xpts))\n plt.plot(xpts, np.arctan(xpts))\n# plt.plot(xpts, np.arccos(xpts) / np.arcsin(xpts))\n ax = plt.gca()\n ax.spines[\"bottom\"].set_position(\"zero\")\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n plt.show()\nplot_math_functions(1, -1, 20)\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": "61c2b2a523f30e24a88fb1e6569a9ea003d2b973", "size": 203540, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "MathConcepts/a_highSchollMath/High-School Maths Exercise.ipynb", "max_stars_repo_name": "KaPrimov/ai-module", "max_stars_repo_head_hexsha": "d0a40482830085ddf020aa5dece88b791699325f", "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": "MathConcepts/a_highSchollMath/High-School Maths Exercise.ipynb", "max_issues_repo_name": "KaPrimov/ai-module", "max_issues_repo_head_hexsha": "d0a40482830085ddf020aa5dece88b791699325f", "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": "MathConcepts/a_highSchollMath/High-School Maths Exercise.ipynb", "max_forks_repo_name": "KaPrimov/ai-module", "max_forks_repo_head_hexsha": "d0a40482830085ddf020aa5dece88b791699325f", "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": 220.9989142237, "max_line_length": 18206, "alphanum_fraction": 0.8849906652, "converted": true, "num_tokens": 7761, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3276682876897044, "lm_q2_score": 0.3007455914759599, "lm_q1q2_score": 0.09854479298915515}} {"text": "```python\nfrom IPython.display import Image\nImage('../../Python_probability_statistics_machine_learning_2E.png',width=200)\n```\n\nWe considered Maximum Likelihood Estimation (MLE) and Maximum A-Posteriori\n(MAP)\nestimation and in each case we started out with a probability density\nfunction\nof some kind and we further assumed that the samples were identically\ndistributed and independent (iid). The idea behind robust statistics\n[[maronna2006robust]](#maronna2006robust) is to construct estimators that can\nsurvive the\nweakening of either or both of these assumptions. More concretely,\nsuppose you\nhave a model that works great except for a few outliers. The\ntemptation is to\njust ignore the outliers and proceed. Robust estimation methods\nprovide a\ndisciplined way to handle outliers without cherry-picking data that\nworks for\nyour favored model.\n\n### The Notion of Location\n\nThe first notion we\nneed is *location*, which is a generalization of the idea\nof *central value*.\nTypically, we just use an estimate of the mean for this,\nbut we will see later\nwhy this could be a bad idea. The general idea of\nlocation satisfies the\nfollowing requirements Let $X$ be a random variable with\ndistribution $F$, and\nlet $\\theta(X)$ be some descriptive measure of $F$. Then\n$\\theta(X)$ is said to\nbe a measure of *location* if for any constants *a* and\n*b*, we have the\nfollowing:\n\n\n\n\n$$\n\\begin{equation}\n\\theta(X+b) = \\theta(X) +b \n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\n\n\n\n$$\n\\begin{equation} \\\n\\theta(-X) = -\\theta(X) \n\\label{_auto2} \\tag{2}\n\\end{equation}\n$$\n\n\n\n\n$$\n\\begin{equation} \\\nX \\ge 0 \\Rightarrow \\theta(X) \\ge 0 \n\\label{_auto3} \\tag{3}\n\\end{equation}\n$$\n\n\n\n\n$$\n\\begin{equation} \\\n\\theta(a X) = a\\theta(X)\n\\label{_auto4} \\tag{4}\n\\end{equation}\n$$\n\n The first condition is called *location equivariance* (or *shift-invariance* in\nsignal processing lingo). The fourth condition is called *scale equivariance*,\nwhich means that the units that $X$ is measured in should not effect the value\nof the location estimator. These requirements capture the intuition of\n*centrality* of a distribution, or where most of the\nprobability mass is\nlocated.\n\nFor example, the sample mean estimator is $ \\hat{\\mu}=\\frac{1}{n}\\sum\nX_i $. The first\nrequirement is obviously satisfied as $\n\\hat{\\mu}=\\frac{1}{n}\\sum (X_i+b) = b +\n\\frac{1}{n}\\sum X_i =b+\\hat{\\mu}$. Let\nus consider the second requirement:$\n\\hat{\\mu}=\\frac{1}{n}\\sum -X_i =\n-\\hat{\\mu}$. Finally, the last requirement is\nsatisfied with $\n\\hat{\\mu}=\\frac{1}{n}\\sum a X_i =a \\hat{\\mu}$.\n\n### Robust Estimation and Contamination\n\nNow that we have the generalized location of centrality embodied\nin the\n*location* parameter, what can we do with it? Previously, we assumed\nthat our samples\nwere all identically distributed. The key idea is that the\nsamples might be\nactually coming from a *single* distribution that is\ncontaminated by another nearby\ndistribution, as in the following:\n\n$$\nF(X) = \\epsilon G(X) + (1-\\epsilon)H(X)\n$$\n\n where $ \\epsilon $ randomly toggles between zero and one. This means\nthat our\ndata samples $\\lbrace X_i \\rbrace$ actually derived from two separate\ndistributions, $ G(X) $ and $ H(X) $. We just don't know how they are mixed\ntogether. What we really want is an estimator that captures the location of $\nG(X) $ in the face of random intermittent contamination by $ H(X)$. For\nexample, it may be that this contamination is responsible for the outliers in a\nmodel that otherwise works well with the dominant $F$ distribution. It can get\neven worse than that because we don't know that there is only one contaminating\n$H(X)$ distribution out there. There may be a whole family of distributions\nthat\nare contaminating $G(X)$. This means that whatever estimators we construct\nhave\nto be derived from a more generalized family of distributions instead of\nfrom a\nsingle distribution, as the maximum-likelihood method assumes. This is\nwhat\nmakes robust estimation so difficult --- it has to deal with *spaces* of\nfunction distributions instead of parameters from a particular probability\ndistribution.\n\n### Generalized Maximum Likelihood Estimators\n\nM-estimators are\ngeneralized maximum likelihood estimators. Recall that for\nmaximum likelihood,\nwe want to maximize the likelihood function as in the\nfollowing:\n\n$$\nL_{\\mu}(x_i) = \\prod f_0(x_i-\\mu)\n$$\n\n and then to find the estimator $\\hat{\\mu}$ so that\n\n$$\n\\hat{\\mu} = \\arg \\max_{\\mu} L_{\\mu}(x_i)\n$$\n\n So far, everything is the same as our usual maximum-likelihood\nderivation\nexcept for the fact that we don't assume a specific $f_0$ as the\ndistribution of\nthe $\\lbrace X_i\\rbrace$. Making the definition of\n\n$$\n\\rho = -\\log f_0\n$$\n\n we obtain the more convenient form of the likelihood product and the\noptimal\n$\\hat{\\mu}$ as\n\n$$\n\\hat{\\mu} = \\arg \\min_{\\mu} \\sum \\rho(x_i-\\mu)\n$$\n\n If $\\rho$ is differentiable, then differentiating this with respect\nto $\\mu$\ngives\n\n\n\n\n$$\n\\begin{equation}\n\\sum \\psi(x_i-\\hat{\\mu}) = 0 \n\\label{eq:muhat} \\tag{5}\n\\end{equation}\n$$\n\n with $\\psi = \\rho^\\prime$, the first derivative of $\\rho$ , and for technical\nreasons we will assume that\n$\\psi$ is increasing. So far, it looks like we just\npushed some definitions\naround, but the key idea is we want to consider general\n$\\rho$ functions that\nmay not be maximum likelihood estimators for *any*\ndistribution. Thus, our\nfocus is now on uncovering the nature of $\\hat{\\mu}$.\n\n### Distribution of M-estimates\n\nFor a given distribution $F$, we define\n$\\mu_0=\\mu(F)$ as the solution to the\nfollowing\n\n$$\n\\mathbb{E}_F(\\psi(x-\\mu_0))= 0\n$$\n\n It is technical to show, but it turns out that $\\hat{\\mu} \\sim\n\\mathcal{N}(\\mu_0,\\frac{v}{n})$ with\n\n$$\nv =\n\\frac{\\mathbb{E}_F(\\psi(x-\\mu_0)^2)}{(\\mathbb{E}_F(\\psi^\\prime(x-\\mu_0)))^2}\n$$\n\n Thus, we can say that $\\hat{\\mu}$ is asymptotically normal with asymptotic\nvalue $\\mu_0$ and asymptotic variance $v$. This leads to the efficiency ratio\nwhich is defined as the following:\n\n$$\n\\texttt{Eff}(\\hat{\\mu})= \\frac{v_0}{v}\n$$\n\n where $v_0$ is the asymptotic variance of the MLE and measures how\nnear\n$\\hat{\\mu}$ is to the optimum. In other words, this provides a sense of\nhow much\noutlier contamination costs in terms of samples. For example, if for\ntwo\nestimates with asymptotic variances $v_1$ and $v_2$, we have $v_1=3v_2$,\nthen\nfirst estimate requires three times as many observations to obtain the\nsame\nvariance as the second. Furthermore, for the sample mean (i.e.,\n$\\hat{\\mu}=\\frac{1}{n} \\sum X_i$) with $F=\\mathcal{N}$, we have $\\rho=x^2/2$\nand\n$\\psi=x$ and also $\\psi'=1$. Thus, we have $v=\\mathbb{V}(x)$.\nAlternatively,\nusing the sample median as the estimator for the location, we\nhave $v=1/(4\nf(\\mu_0)^2)$. Thus, if we have $F=\\mathcal{N}(0,1)$, for the\nsample median, we\nobtain $v={2\\pi}/{4} \\approx 1.571$. This means that the\nsample median takes\napproximately 1.6 times as many samples to obtain the same\nvariance for the\nlocation as the sample mean. The sample median is \nfar more immune to the\neffects of outliers than the sample mean, so this \ngives a sense of how much\nthis robustness costs in samples.\n\n** M-Estimates as Weighted Means.** One way\nto think about M-estimates is a\nweighted means. Operationally, this\nmeans that\nwe want weight functions that can circumscribe the\ninfluence of the individual\ndata points, but, when taken as a whole,\nstill provide good estimated\nparameters. Most of the time, we have $\\psi(0)=0$ and $\\psi'(0)$ exists so\nthat\n$\\psi$ is approximately linear at the origin. Using the following\ndefinition:\n\n$$\nW(x) = \\begin{cases}\n \\psi(x)/x & \\text{if} \\: x \\neq 0 \\\\\\\n\\psi'(x) & \\text{if} \\: x =0 \n \\end{cases}\n$$\n\n We can write our Equation [5](#eq:muhat) as follows:\n\n\n\n\n$$\n\\begin{equation}\n\\sum W(x_i-\\hat{\\mu})(x_i-\\hat{\\mu}) = 0 \n\\label{eq:Wmuhat}\n\\tag{6}\n\\end{equation}\n$$\n\n Solving this for $\\hat{\\mu} $ yields the following,\n\n$$\n\\hat{\\mu} = \\frac{\\sum w_{i} x_i}{\\sum w_{i}}\n$$\n\n where $w_{i}=W(x_i-\\hat{\\mu})$. This is not practically useful\nbecause the\n$w_i$ contains $\\hat{\\mu}$, which is what we are trying to solve\nfor. The\nquestion that remains is how to pick the $\\psi$ functions. This is\nstill an open\nquestion, but the Huber functions are a well-studied choice.\n\n### Huber\nFunctions\n\nThe family of Huber functions is defined by the following:\n\n$$\n\\rho_k(x ) = \\begin{cases}\n x^2 & \\mbox{if } |x|\\leq\nk \\\\\\\n 2 k |x|-k^2 & \\mbox{if } |x| > k\n\\end{cases}\n$$\n\n with corresponding derivatives $2\\psi_k(x)$ with\n\n$$\n\\psi_k(x ) = \\begin{cases}\n x & \\mbox{if } \\: |x|\n\\leq k \\\\\\\n \\text{sgn}(x)k & \\mbox{if } \\: |x| > k\n\\end{cases}\n$$\n\n where the limiting cases $k \\rightarrow \\infty$ and $k \\rightarrow 0$\ncorrespond to the mean and median, respectively. To see this, take\n$\\psi_{\\infty} = x$ and therefore $W(x) = 1$ and thus the defining Equation\n[6](#eq:Wmuhat) results in\n\n$$\n\\sum_{i=1}^{n} (x_i-\\hat{\\mu}) = 0\n$$\n\n and then solving this leads to $\\hat{\\mu} = \\frac{1}{n}\\sum x_i$.\nNote that\nchoosing $k=0$ leads to the sample median, but that is not so\nstraightforward\nto solve for. Nonetheless, Huber functions provide a way\nto move between two\nextremes of estimators for location (namely, \nthe mean vs. the median) with a\ntunable parameter $k$. \nThe $W$ function corresponding to Huber's $\\psi$ is the\nfollowing:\n\n$$\nW_k(x) = \\min\\Big{\\lbrace} 1, \\frac{k}{|x|} \\Big{\\rbrace}\n$$\n\n [Figure](#fig:Robust_Statistics_0001) shows the Huber weight\nfunction for $k=2$\nwith some sample points. The idea is that the computed\nlocation, $\\hat{\\mu}$ is\ncomputed from Equation [6](#eq:Wmuhat) to lie somewhere\nin the middle of the\nweight function so that those terms (i.e., *insiders*)\nhave their values fully\nreflected in the location estimate. The black circles\nare the *outliers* that\nhave their values attenuated by the weight function so\nthat only a fraction of\ntheir presence is represented in the location estimate.\n\n\n\nThis shows the Huber weight function,\n$W_2(x)$ and some cartoon data points that are insiders or outsiders as far as\nthe robust location estimate is concerned.
\n\n\n\n\n\n###\nBreakdown Point\n\nSo far, our discussion of robustness has been very abstract. A\nmore concrete\nconcept of robustness comes from the breakdown point. In the\nsimplest terms,\nthe breakdown point describes what happens when a single data\npoint in an\nestimator is changed in the most damaging way possible. For example,\nsuppose we\nhave the sample mean, $\\hat{\\mu}=\\sum x_i/n$, and we take one of the\n$x_i$\npoints to be infinite. What happens to this estimator? It also goes\ninfinite.\nThis means that the breakdown point of the estimator is 0%. On the\nother hand,\nthe median has a breakdown point of 50%, meaning that half of the\ndata for\ncomputing the median could go infinite without affecting the median\nvalue. The median\nis a *rank* statistic that cares more about the relative\nranking of the data\nthan the values of the data, which explains its robustness.\nThe simpliest but still formal way to express the breakdown point is to\ntake $n$\ndata points, $\\mathcal{D} = \\lbrace (x_i,y_i) \\rbrace$. Suppose $T$\nis a\nregression estimator that yields a vector of regression coefficients,\n$\\boldsymbol{\\theta}$,\n\n$$\nT(\\mathcal{D}) = \\boldsymbol{\\theta}\n$$\n\n Likewise, consider all possible corrupted samples of the data\n$\\mathcal{D}^\\prime$. The maximum *bias* caused by this contamination is\nthe\nfollowing:\n\n$$\n\\texttt{bias}_{m} = \\sup_{\\mathcal{D}^\\prime} \\Vert\nT(\\mathcal{D^\\prime})-T(\\mathcal{D}) \\Vert\n$$\n\n where the $\\sup$ sweeps over all possible sets of $m$ contaminated samples.\nUsing this, the breakdown point is defined as the following:\n\n$$\n\\epsilon_m = \\min \\Big\\lbrace \\frac{m}{n} \\colon \\texttt{bias}_{m}\n\\rightarrow \\infty \\Big\\rbrace\n$$\n\n For example, in our least-squares regression, even one point at\ninfinity causes\nan infinite $T$. Thus, for least-squares regression,\n$\\epsilon_m=1/n$. In the\nlimit $n \\rightarrow \\infty$, we have $\\epsilon_m\n\\rightarrow 0$.\n\n###\nEstimating Scale\n\nIn robust statistics, the concept of *scale* refers to a\nmeasure of the\ndispersion of the data. Usually, we use the\nestimated standard\ndeviation for this, but this has a terrible breakdown point.\nEven more\ntroubling, in order to get a good estimate of location, we have to\neither\nsomehow know the scale ahead of time, or jointly estimate it. None of\nthese\nmethods have easy-to-compute closed form solutions and must be computed\nnumerically.\n\nThe most popular method for estimating scale is the *median\nabsolute deviation*\n\n$$\n\\texttt{MAD} = \\texttt{Med} (\\vert \\mathbf{x} -\n\\texttt{Med}(\\mathbf{x})\\vert)\n$$\n\n In words, take the median of the data $\\mathbf{x}$ and\nthen subtract that\nmedian from the data itself, and then take the median of the\nabsolute value of\nthe result. Another good dispersion estimate is the *interquartile range*,\n\n$$\n\\texttt{IQR} = x_{(n-m+1)} - x_{(n)}\n$$\n\n where $m= [n/4]$. The $x_{(n)}$ notation means the $n^{th}$ data\nelement after\nthe data have been sorted. Thus, in this notation,\n$\\texttt{max}(\\mathbf{x})=x_{(n)}$. In the case where $x \\sim\n\\mathcal{N}(\\mu,\\sigma^2)$, then $\\texttt{MAD}$ and $\\texttt{IQR}$ are constant\nmultiples of $\\sigma$ such that the normalized $\\texttt{MAD}$ is the following,\n\n$$\n\\texttt{MADN}(x) = \\frac{\\texttt{MAD} }{0.675}\n$$\n\n The number comes from the inverse CDF of the normal distribution\ncorresponding\nto the $0.75$ level. Given the complexity of the\ncalculations, *jointly*\nestimating both location and scale is a purely\nnumerical matter. Fortunately,\nthe Statsmodels module has many of these\nready to use. Let's create some\ncontaminated data in the following code,\n\n\n```python\nimport statsmodels.api as sm\nimport numpy as np\n\nfrom scipy import stats\ndata=np.hstack([stats.norm(10,1).rvs(10),\n stats.norm(0,1).rvs(100)])\n```\n\nThese data correspond to our model of contamination that we started\nthis\nsection with. As shown in the histogram in\n[Figure](#fig:Robust_Statistics_0002), there are two normal distributions, one\ncentered neatly at zero, representing the majority of the samples, and another\ncoming less regularly from the normal distribution on the right. Notice that\nthe\ngroup of infrequent samples on the right separates the mean and median\nestimates\n(vertical dotted and dashed lines). In the absence of the\ncontaminating\ndistribution on the right, the standard deviation for this data\nshould be close\nto one. However, the usual non-robust estimate for standard\ndeviation (`np.std`)\ncomes out to approximately three. Using the\n$\\texttt{MADN}$ estimator\n(`sm.robust.scale.mad(data)`) we obtain approximately\n1.25. Thus, the robust\nestimate of dispersion is less moved by the presence of\nthe contaminating\ndistribution.\n\n\n\n\nHistogram of sample data. Notice that the group of infrequent samples on the\nright separates the mean and median estimates indicated by the vertical\nlines.
\n\n\n\n\n\nThe generalized maximum likelihood M-estimation extends to\njoint\nscale and location estimation using Huber functions. For example,\n\n\n```python\nhuber = sm.robust.scale.Huber()\nloc,scl=huber(data)\n```\n\nwhich implements Huber's *proposal two* method of joint estimation of\nlocation\nand scale. This kind of estimation is the key ingredient to robust\nregression\nmethods, many of which are implemented in Statsmodels in\n`statsmodels.formula.api.rlm`. The corresponding documentation has more\ninformation.\n", "meta": {"hexsha": "9f7c38e6ba987f7c0bc99a6106676af9d5c72fb1", "size": 199747, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapter/statistics/Robust_Statistics.ipynb", "max_stars_repo_name": "derakding/Python-for-Probability-Statistics-and-Machine-Learning-2E", "max_stars_repo_head_hexsha": "9d12a298d43ae285d9549a79bb5544cf0a9b7516", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 224, "max_stars_repo_stars_event_min_datetime": "2019-05-07T08:56:01.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-25T15:50:41.000Z", "max_issues_repo_path": "chapter/statistics/Robust_Statistics.ipynb", "max_issues_repo_name": "derakding/Python-for-Probability-Statistics-and-Machine-Learning-2E", "max_issues_repo_head_hexsha": "9d12a298d43ae285d9549a79bb5544cf0a9b7516", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 9, "max_issues_repo_issues_event_min_datetime": "2019-08-27T12:57:17.000Z", "max_issues_repo_issues_event_max_datetime": "2021-09-21T15:45:13.000Z", "max_forks_repo_path": "chapter/statistics/Robust_Statistics.ipynb", "max_forks_repo_name": "derakding/Python-for-Probability-Statistics-and-Machine-Learning-2E", "max_forks_repo_head_hexsha": "9d12a298d43ae285d9549a79bb5544cf0a9b7516", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 73, "max_forks_repo_forks_event_min_datetime": "2019-05-25T07:15:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-07T00:22:37.000Z", "avg_line_length": 317.0587301587, "max_line_length": 176652, "alphanum_fraction": 0.9212403691, "converted": true, "num_tokens": 4677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3345894545235253, "lm_q2_score": 0.2942149659744614, "lm_q1q2_score": 0.09844122497805259}} {"text": "# Implementing Neural Networks with Numpy for Absolute Beginners - Part 1: Introduction\n\n##### In this tutorial, you will get a brief understanding of what Neural Networks are and how they have been developed. In the end, you will gain a brief intuition as to how the network learns.\n\nThe field of Artificial Intelligence has gained a lot of popularity and momentum during the past 10 years, largely due to a huge increase in the computational capacity of computers with the use of GPUs and the availability of gigantic amounts of data. Deep Learning has become the buzzword everywhere!!\n>>>>> \n\n\nAlthough Artificial Intelligence (AI) resonates with the notion of the machines to think and behave impersonating humans, it is rather restricted to very nascent and small task-specific functions while the term Artificial General Intelligence (AGI) obliges to the terms of impersonating a human. Above these is the concept of Artificial Super Intelligence (ASI) which gives me the shrills as it represents intelligence of machines far exceeding human levels!!\n\nThe main concept for Artificial Intelligence currently holds that you have to train it before it learns to perform the task much like humans, except that here… you have to train it even for the simplest of the tasks like seeing and identifying objects!(This is surely a complex problem for our computers).\n\nThere are 3 situations that you can encounter in this domain:\n1. When you have a lot of data...\n\n> - Either your data is tagged, labelled, maintained or it is not.\n If the data is available and is fully labelled or tagged, you can train the model based on the given set of input-output pairs and ask the model to predict the output for a new set of data. This type of learning is called **Supervised Learning** (Since, you are giving the input and also mentioning that this is the correct output for the data).\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# This is just a test title\n## With a subtitle\n### And an even smaller subtitle\n
Write your formulas here.
\n\nEquation of a line: $$ y = ax + b $$\n\nRoots of the quadratic equation $ax^{2}+bx+c=0$: $$ x_{1,2}=\\frac{-b\\pm\\sqrt[2]{b^{2}-4ac}}{2a} $$\n\nTaylor series expansion: $$f(x)\\mid_{x=a}=f(a)+f'(a)(x-a)+\\frac{f''(a)}{2!}(x-a)^{2}+...+\\frac{f^{n}(a)}{n!}(x-a)^{n}+...$$\n\nBinomial theorem: $$ (x+y)^{n}=\\biggl({n \\atop 0}\\biggr)x^{n}y^{0}+\\biggl({n \\atop 1}\\biggr)x^{n-1}y^{1}+...+\\biggl({n \\atop n}\\biggr)x^{0}y^{n}=\\sum^{n}_{k=0}\\biggl({n \\atop k}\\biggr)x^{n-k}y^{k} $$\n\nAn integral (this one is a lot of fun to solve :D): $$ \\int_{+\\infty}^{-\\infty} e^{-x^{2}} \\,dx=\\sqrt{\\pi}$$\n\nA short matrix: $$\\begin{pmatrix} 2 & 1 & 3 \\\\ 2 & 6 & 8 \\\\ 6 & 8 & 18\\end{pmatrix}$$\n\nA long matrix: $$\\begin{pmatrix} a_{11} & a_{12} & \\cdots & a_{1n}\\\\ a_{21} & a_{22} & \\cdots & a_{2n} \\\\ \\vdots & \\vdots & \\ddots & \\vdots \\\\a_{m1} & a_{m2} & \\cdots & a_{mn}\\end{pmatrix}$$\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\n\n```python\n# High-School Maths Exercise\n## Getting to Know Jupyter Notebook. Python Libraries and Best Practices. Basic Workflow\n```\n\n\n```python\n# Write your code here\nx = sympy.symbols('x')\na, b, c = sympy.symbols('a b c')\nsympy.solve(a * x**2 + b * x + c)\n```\n\n\n\n\n [{a: (-b*x - c)/x**2}]\n\n\n\n\n```python\n# Write your code here\nsympy.init_printing()\nsympy.solve(a * x**2 + b * x + c, x)\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 parameter:\n```python \nsympy.solve(a * x**2 + b * x + c, x)\n```\n\nFinally, if we start with `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. **Note:** This means we have to add the line BEFORE we start working with `sympy`.\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\ndef format_decimal(func):\n \"\"\"\n Decorator to convert the sympy output to Python float format\n \"\"\"\n def inner(*args, **kwargs):\n raw_res = func(*args, **kwargs)\n if isinstance(raw_res, list) and len(raw_res) > 0:\n retval = []\n for el in raw_res:\n retval.append(float(el))\n return retval\n return raw_res\n return inner\n\n@format_decimal\ndef solve_quadratic_equation(a, b, c):\n \"\"\"\n Returns the real solutions of the quadratic equation ax^2 + bx + c = 0\n \"\"\"\n # Delete the \"pass\" statement below and write your code\n def sqrt_part():\n return b**2 - 4 * a * c\n \n if a == 0:\n return sympy.solve(b * x + c, x)\n if sqrt_part() < 0:\n return []\n return sympy.solve(a * x**2 + b * x + c, x)\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\n```python\n# Bonus: Calling the function with a = 0 for a linear equation\nprint(solve_quadratic_equation(0, -1, -2)) # [-2.0]\nprint(solve_quadratic_equation(0, -8, 16)) # [2.0]\nprint(solve_quadratic_equation(0, 1, 1)) # [-1.0]\n```\n\n [-2.0]\n [2.0]\n [-1.0]\n\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? We 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\n# Write your code here\nx = np.linspace(-3, 5, 1000)\ny = 2 * x + 3\nplt.plot(x, y)\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 zero. 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\nplt.clf()\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)\nxticks = ax.xaxis.get_major_ticks()\nyticks = ax.yaxis.get_major_ticks()\n\nplt.plot(x, y)\n\n# Let's try to remove the double 0 at the origin.\nxloc, labels = plt.xticks()\nyloc, labels = plt.yticks()\nx_zero_loc = np.where(xloc==0)[0][0]\ny_zero_loc = np.where(yloc==0)[0][0]\n\nxticks[x_zero_loc].set_visible(False)\nyticks[y_zero_loc].set_visible(False)\n\nplt.show()\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\nWrite your result here.
\nWe start by taking the ln of both sides: $ \\ln(y) = \\ln(a) + bx\\ln(e) $\n\nThe resulting linear function is: $ \\ln(y) = \\ln(a) + bx $\n\nWhere **ln(y)** is the dependent that we plot on the y-axis, **ln(a)** is the constant and **b** is the slope. This equation is commontly presented as $y = mx + b$\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 remove_zero_tick(loc, axticks):\n \"\"\"\n This function will be used in this book to remove the 0 at origin\n \"\"\"\n try:\n zero_loc = np.where(loc==0)[0][0]\n axticks[zero_loc].set_visible(False)\n except IndexError:\n ax.spines[\"bottom\"].set_position(('data', 1))\n\ndef plot_math_function(f, min_x, max_x, num_points):\n x_array = np.linspace(min_x, max_x, num_points)\n f_vectorized = np.vectorize(f)\n y = f_vectorized(x_array)\n\n \n plt.clf()\n plt.cla()\n ax = plt.gca()\n ax.spines[\"bottom\"].set_position('zero')\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n xticks = ax.xaxis.get_major_ticks()\n yticks = ax.yaxis.get_major_ticks()\n \n plt.plot(x_array, y)\n\n xloc, labels = plt.xticks()\n yloc, labels = plt.yticks()\n remove_zero_tick(xloc, xticks)\n remove_zero_tick(yloc, yticks)\n\n plt.show()\n \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 \n x_array = np.linspace(min_x, max_x, num_points)\n if hasattr(functions, \"__iter__\"):\n vectorized_fs = [np.vectorize(func) for func in functions]\n ys = [vectorized_f(x_array) for vectorized_f in vectorized_fs]\n else:\n ys = [np.vectorize(functions)(x_array)]\n \n ax = plt.gca()\n ax.spines[\"bottom\"].set_position('zero')\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n xticks = ax.xaxis.get_major_ticks()\n yticks = ax.yaxis.get_major_ticks()\n\n for y in ys:\n plt.plot(x_array, y)\n\n xloc, labels = plt.xticks()\n yloc, labels = plt.yticks()\n remove_zero_tick(xloc, xticks)\n remove_zero_tick(yloc, yticks)\n \n plt.show()\n```\n\n\n```python\n# plot_math_functions(4, -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 then again, how do we define the trigonometric functions? 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\nplot_math_functions([lambda x: np.arcsin(x), lambda x: np.arccos(x)], -1, 1, 1000)\nplot_math_functions(lambda x: np.arctan(x), -1, 1, 1000)\n\nplot_math_functions(lambda x: np.arctan(1 / x), -1, 1, 1000)\nplot_math_functions(lambda x: (3.14 / 2) - np.arctan(x), -1, 1, 1000)\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": "d9f585fbf3da4e67e9e5ca586b0fe671e2f5b9d8", "size": 231148, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Math/High School Math/High-School Maths Exercise.ipynb", "max_stars_repo_name": "tankishev/Python_Fundamentals", "max_stars_repo_head_hexsha": "dce38de592ff06ec68153a4fcd4d609af2c1cf83", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2022-02-07T21:12:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-07T21:12:35.000Z", "max_issues_repo_path": "Math/High School Math/High-School Maths Exercise.ipynb", "max_issues_repo_name": "tankishev/Python_Fundamentals", "max_issues_repo_head_hexsha": "dce38de592ff06ec68153a4fcd4d609af2c1cf83", "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/High School Math/High-School Maths Exercise.ipynb", "max_forks_repo_name": "tankishev/Python_Fundamentals", "max_forks_repo_head_hexsha": "dce38de592ff06ec68153a4fcd4d609af2c1cf83", "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": 215.4221808015, "max_line_length": 17132, "alphanum_fraction": 0.8951407756, "converted": true, "num_tokens": 8396, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3073580295544412, "lm_q2_score": 0.31742626558767584, "lm_q1q2_score": 0.09756351151985276}} {"text": "# Introduction to Neural Networks and Pytorch \n\n Notebook version: 0.1 (Nov 14, 2020)\n\n Authors: Jerónimo Arenas García (jarenas@ing.uc3m.es)\n\n Changes: v.0.1. (Nov 14, 2020) - First version\n \n Pending changes: - Use epochs instead of iters in first part of notebook\n - Add an example with dropout\n - Add theory about CNNs\n - Define functions for the training of neural nets and display of the results\n in order to simplify code cells\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\nsize=18\nparams = {'legend.fontsize': 'Large',\n 'axes.labelsize': size,\n 'axes.titlesize': size,\n 'xtick.labelsize': size*0.75,\n 'ytick.labelsize': size*0.75}\nplt.rcParams.update(params)\n```\n\n## 1. Introduction and purpose of this Notebook \n\n### 1.1. About Neural Networks \n\n* Neural Networks (NN) have become the state of the art for many machine learning problems\n * Natural Language Processing\n * Computer Vision\n * Image Recognition\n\n\n* They are in widespread use for many applications, e.g.,\n * Language Translantion (Google Neural Machine Translation System) \n * Automatic Speech recognition (Hey Siri! DNN overview)\n * Autonomous Navigation (Facebook Robot Autonomous 3D Navigation)\n * Automatic Plate recognition\n \n\n \n\nFeed Forward Neural Networks have been around since 1960 but only recently (last 10-12 years) have they met their expectations, and improve other machine learning algorithms\n\n* Computation resources are now available at large scale\n* Cloud Computing (AWS, Azure)\n* From MultiLayer Perceptrons to Deep Learning\n* Big Data sets\n* This has also made possible an intense research effort resulting in\n * Topologies better suited to particular problems (CNNs, RNNs)\n * New training strategies providing better generalization\n\nIn parallel, Deep Learning Platforms have emerged that make design, implementation, training, and production of DNNs feasible for everyone\n\n### 1.2. Scope\n\n* To provide just an overview of most important NNs and DNNs concepts\n* Connecting with already studied methods as starting point\n* Introduction to PyTorch\n* Providing links to external sources for further study\n\n### 1.3. Outline\n\n1. Introduction and purpose of this Notebook\n2. Introduction to Neural Networks\n3. Implementing Deep Networks with PyTorch\n\n### 1.4. Other resources \n\n* We point here to external resources and tutorials that are excellent material for further study of the topic\n* Most of them include examples and exercises using numpy and PyTorch\n* This notebook uses examples and other material from some of these sources\n\n|Tutorial|Description|\n|-----|---------------------|\n| |Very general tutorial including videos and an overview of top deep learning platforms|\n| |Very complete book with a lot of theory and examples for MxNET, PyTorch, and TensorFlow|\n| |Official tutorials from the PyTorch project. Contains a 60 min overview, and a very practical *learning PyTorch with examples* tutorial|\n| |Kaggle tutorials covering an introduction to Neural Networks using Numpy, and a second one offering a PyTorch tutorial|\n\n\n\n\n\n\nIn addition to this, PyTorch MOOCs can be followed for free in main sites: edX, Coursera, Udacity\n\n## 2. Introduction to Neural Networks \n\nIn this section, we will implement neural networks from scratch using Numpy arrays\n\n* No need to learn any new Python libraries\n* But we need to deal with complexity of multilayer networks\n* Low-level implementation will be useful to grasp the most important concepts concerning DNNs\n * Back-propagation\n * Activation functions\n * Loss functions\n * Optimization methods\n * Generalization\n * Special layers and configurations\n\n### 2.0. Data preparation \n\nWe start by loading some data sets that will be used to carry out the exercises\n\n### Sign language digits data set\n\n* Dataset is taken from Kaggle and used in the above referred tutorial\n* 2062 digits in sign language. $64 \\times 64$ images\n* Problem with 10 classes. One hot encoding for the label matrix\n* Input data are images, we create also a flattened version\n\n\n```python\ndigitsX = np.load('./data/Sign-language-digits-dataset/X.npy')\ndigitsY = np.load('./data/Sign-language-digits-dataset/Y.npy')\nK = digitsX.shape[0]\nimg_size = digitsX.shape[1]\ndigitsX_flatten = digitsX.reshape(K,img_size*img_size)\n\nprint('Size of Input Data Matrix:', digitsX.shape)\nprint('Size of Flattned Input Data Matrix:', digitsX_flatten.shape)\nprint('Size of label Data Matrix:', digitsY.shape)\nselected = [260, 1400]\nplt.subplot(1, 2, 1), plt.imshow(digitsX[selected[0]].reshape(img_size, img_size)), plt.axis('off')\nplt.subplot(1, 2, 2), plt.imshow(digitsX[selected[1]].reshape(img_size, img_size)), plt.axis('off')\nplt.show()\nprint('Labels corresponding to figures:', digitsY[selected,])\n```\n\n### Dogs vs Cats data set\n\n* Dataset is taken from Kaggle\n* 25000 pictures of dogs and cats\n* Binary problem\n* Input data are images, we create also a flattened version\n* Original images are RGB, and arbitrary size\n* Preprocessed images are $64 \\times 64$ and gray scale\n\n\n```python\n# Preprocessing of original Dogs and Cats Pictures\n# Adapted from https://medium.com/@mrgarg.rajat/kaggle-dogs-vs-cats-challenge-complete-step-by-step-guide-part-1-a347194e55b1\n# RGB channels are collapsed in GRAYSCALE\n# Images are resampled to 64x64\n\n\"\"\"\nimport os, cv2 # cv2 -- OpenCV\n\ntrain_dir = './data/DogsCats/train/'\nrows = 64\ncols = 64\ntrain_images = sorted([train_dir+i for i in os.listdir(train_dir)])\n\ndef read_image(file_path):\n image = cv2.imread(file_path, cv2.IMREAD_GRAYSCALE)\n return cv2.resize(image, (rows, cols),interpolation=cv2.INTER_CUBIC)\n\ndef prep_data(images):\n m = len(images)\n X = np.ndarray((m, rows, cols), dtype=np.uint8)\n y = np.zeros((m,))\n print(\"X.shape is {}\".format(X.shape))\n \n for i,image_file in enumerate(images) :\n image = read_image(image_file)\n X[i,] = np.squeeze(image.reshape((rows, cols)))\n if 'dog' in image_file.split('/')[-1].lower():\n y[i] = 1\n elif 'cat' in image_file.split('/')[-1].lower():\n y[i] = 0\n \n if i%5000 == 0 :\n print(\"Proceed {} of {}\".format(i, m))\n \n return X,y\n\nX_train, y_train = prep_data(train_images)\nnp.save('./data/DogsCats/X.npy', X_train)\nnp.save('./data/DogsCats/Y.npy', y_train)\n\"\"\"\n```\n\n\n```python\nDogsCatsX = np.load('./data/DogsCats/X.npy')\nDogsCatsY = np.load('./data/DogsCats/Y.npy')\nK = DogsCatsX.shape[0]\nimg_size = DogsCatsX.shape[1]\nDogsCatsX_flatten = DogsCatsX.reshape(K,img_size*img_size)\n\nprint('Size of Input Data Matrix:', DogsCatsX.shape)\nprint('Size of Flattned Input Data Matrix:', DogsCatsX_flatten.shape)\nprint('Size of label Data Matrix:', DogsCatsY.shape)\nselected = [260, 16000]\nplt.subplot(1, 2, 1), plt.imshow(DogsCatsX[selected[0]].reshape(img_size, img_size)), plt.axis('off')\nplt.subplot(1, 2, 2), plt.imshow(DogsCatsX[selected[1]].reshape(img_size, img_size)), plt.axis('off')\nplt.show()\nprint('Labels corresponding to figures:', DogsCatsY[selected,])\n```\n\n### 2.1. Logistic Regression as a Simple Neural Network \n\n* We can consider logistic regression as an extremely simple (1 layer) neural network\n\n\n\n* In this context, $\\text{NLL}({\\bf w})$ is normally referred to as cross-entropy loss\n\n\n* We need to find parameters $\\bf w$ and $b$ to minimize the loss $\\rightarrow$ GD / SGD\n* Gradient computation can be simplified using the **chain rule**\n\n| \n View on TensorFlow.org\n | \n\n Run in Google Colab\n | \n\n View source on GitHub\n | \n\n Download notebook\n | \n
| Rappresentazione schematica del sistema di controllo dell'azimut di una antenna | \nDiagramma a blocchi del sistema di controllo dell'azimut di una antenna | \n
|---|---|
| \n | \n |
| \n | Legenda: RP = potenziometro di riferimento, MP = potenziometro di misurazione, dw = disturbo dovuto al vento. | \n
\n\n
\n\n\n
\n\n\n
\n\n\n
\n| \n | UV | \nConductivity | \nVolume | \n
|---|---|---|---|
| Time | \n\n | \n | \n |
| 0.0 | \n-0.000730 | \n1.04 | \n0.0 | \n
| 0.2 | \n-0.000724 | \n1.04 | \n0.0 | \n
| \n | Abbr. | \nAbbr..1 | \nMolecular Weight | \nMolecular Formula | \nResidue Formula | \nResidue Weight (-H2O) | \npKa1 | \npKb2 | \npKx3 | \npl4 | \n
|---|---|---|---|---|---|---|---|---|---|---|
| Name | \n\n | \n | \n | \n | \n | \n | \n | \n | \n | \n |
| Alanine | \nAla | \nA | \n89.10 | \nC3H7NO2 | \nC3H5NO | \n71.08 | \n2.34 | \n9.69 | \nNaN | \n6.00 | \n
| Aspartic acid | \nAsp | \nD | \n133.11 | \nC4H7NO4 | \nC4H5NO3 | \n115.09 | \n1.88 | \n9.60 | \n3.65 | \n2.77 | \n
| Glutamine | \nGln | \nQ | \n146.15 | \nC5H10N2O3 | \nC5H8N2O2 | \n128.13 | \n2.17 | \n9.13 | \nNaN | \n5.65 | \n
| Hydroxyproline | \nHyp | \nO | \n131.13 | \nC5H9NO3 | \nC5H7NO2 | \n113.11 | \n1.82 | \n9.65 | \nNaN | \nNaN | \n
| Lysine | \nLys | \nK | \n146.19 | \nC6H14N2O2 | \nC6H12N2O | \n128.18 | \n2.18 | \n8.95 | \n10.53 | \n9.74 | \n
| Proline | \nPro | \nP | \n115.13 | \nC5H9NO2 | \nC5H7NO | \n97.12 | \n1.99 | \n10.60 | \nNaN | \n6.30 | \n
| Threonine | \nThr | \nT | \n119.12 | \nC4H9NO3 | \nC4H7NO2 | \n101.11 | \n2.09 | \n9.10 | \nNaN | \n5.60 | \n
| Valine | \nVal | \nV | \n117.15 | \nC5H11NO2 | \nC5H9NO | \n99.13 | \n2.32 | \n9.62 | \nNaN | \n5.96 | \n
| \n | pKa1 | \npKb2 | \npKx3 | \n
|---|---|---|---|
| Name | \n\n | \n | \n |
| Arginine | \n2.17 | \n9.04 | \n12.48 | \n
| Asparagine | \n2.02 | \n8.80 | \nNaN | \n
| Aspartic acid | \n1.88 | \n9.60 | \n3.65 | \n
| Cysteine | \n1.96 | \n10.28 | \n8.18 | \n
| Glutamic acid | \n2.19 | \n9.67 | \n4.25 | \n
| \n | Abbr. | \nAbbr..1 | \nMolecular Weight | \nMolecular Formula | \nResidue Formula | \nResidue Weight (-H2O) | \npKa1 | \npKb2 | \npKx3 | \npl4 | \n
|---|---|---|---|---|---|---|---|---|---|---|
| Name | \n\n | \n | \n | \n | \n | \n | \n | \n | \n | \n |
| Arginine | \nArg | \nR | \n174.20 | \nC6H14N4O2 | \nC6H12N4O | \n156.19 | \n2.17 | \n9.04 | \n12.48 | \n10.76 | \n
| Histidine | \nHis | \nH | \n155.16 | \nC6H9N3O2 | \nC6H7N3O | \n137.14 | \n1.82 | \n9.17 | \n6.00 | \n7.59 | \n
| Lysine | \nLys | \nK | \n146.19 | \nC6H14N2O2 | \nC6H12N2O | \n128.18 | \n2.18 | \n8.95 | \n10.53 | \n9.74 | \n
Diffraction and crystallography
\n\n\n11.2 Describe the “phase problem” in X-ray crystallography, and at least one way the problem can be addressed (or at least circumvented to solve X-ray structures).
\n\nSee Page 420 for phase problem, See Page 421 for the way the problem can be addressed.
\n\n\n\n11.20 Draw a set of points as a rectangular array based on unit cells of side a and b, and mark the planes with Miller indices (1,0,0), (0,1,0), (1,1,0), (1,2,0), (2,3,0), (4,1,0).\n
\n\nHere's an example...\n\n$$(1,2,0) = (k,h,l) \\implies (\\frac{a}{h},\\frac{b}{k},0) = (\\frac{a}{1},\\frac{b}{2},0) \\\\ \\implies 2\\times(\\frac{a}{1},\\frac{b}{2},0) = (2a,b,0)$$\n\nWhat kind of information can be obtained using FRET spectroscopy? What is the distance dependence of the FRET effect?
\n\nFörster resonance energy transfer (FRET) spectroscopy is useful for studying processes involving inter and intra-molecular energy transfer and can be used to measure distances (ranging from 1 to 9 nm) in biological systems. Furthermore, conformational changes can be studied, and also good for studying bulk distances. Single molecule FRET —create histograms of binned FRET distances, ultimately revealing states.See Pages 500,501 for more information.
\n\n| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \nocean_proximity | \n
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n-122.23 | \n37.88 | \n41.0 | \n880.0 | \n129.0 | \n322.0 | \n126.0 | \n8.3252 | \n452600.0 | \nNEAR BAY | \n
| 1 | \n-122.22 | \n37.86 | \n21.0 | \n7099.0 | \n1106.0 | \n2401.0 | \n1138.0 | \n8.3014 | \n358500.0 | \nNEAR BAY | \n
| 2 | \n-122.24 | \n37.85 | \n52.0 | \n1467.0 | \n190.0 | \n496.0 | \n177.0 | \n7.2574 | \n352100.0 | \nNEAR BAY | \n
| 3 | \n-122.25 | \n37.85 | \n52.0 | \n1274.0 | \n235.0 | \n558.0 | \n219.0 | \n5.6431 | \n341300.0 | \nNEAR BAY | \n
| 4 | \n-122.25 | \n37.85 | \n52.0 | \n1627.0 | \n280.0 | \n565.0 | \n259.0 | \n3.8462 | \n342200.0 | \nNEAR BAY | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \n
|---|---|---|---|---|---|---|---|---|---|
| count | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n20433.000000 | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n
| mean | \n-119.569704 | \n35.631861 | \n28.639486 | \n2635.763081 | \n537.870553 | \n1425.476744 | \n499.539680 | \n3.870671 | \n206855.816909 | \n
| std | \n2.003532 | \n2.135952 | \n12.585558 | \n2181.615252 | \n421.385070 | \n1132.462122 | \n382.329753 | \n1.899822 | \n115395.615874 | \n
| min | \n-124.350000 | \n32.540000 | \n1.000000 | \n2.000000 | \n1.000000 | \n3.000000 | \n1.000000 | \n0.499900 | \n14999.000000 | \n
| 25% | \n-121.800000 | \n33.930000 | \n18.000000 | \n1447.750000 | \n296.000000 | \n787.000000 | \n280.000000 | \n2.563400 | \n119600.000000 | \n
| 50% | \n-118.490000 | \n34.260000 | \n29.000000 | \n2127.000000 | \n435.000000 | \n1166.000000 | \n409.000000 | \n3.534800 | \n179700.000000 | \n
| 75% | \n-118.010000 | \n37.710000 | \n37.000000 | \n3148.000000 | \n647.000000 | \n1725.000000 | \n605.000000 | \n4.743250 | \n264725.000000 | \n
| max | \n-114.310000 | \n41.950000 | \n52.000000 | \n39320.000000 | \n6445.000000 | \n35682.000000 | \n6082.000000 | \n15.000100 | \n500001.000000 | \n
| \n | Overall | \nStratified tr | \nRandom tr | \nStratified ts | \nRandom ts | \nRand. tr %error | \nRand. ts %error | \nStrat. tr %error | \nStrat. ts %error | \n
|---|---|---|---|---|---|---|---|---|---|
| 1.0 | \n0.039826 | \n0.039850 | \n0.039729 | \n0.039729 | \n0.040213 | \n-0.243309 | \n0.973236 | \n0.060827 | \n-0.243309 | \n
| 2.0 | \n0.318847 | \n0.318859 | \n0.317466 | \n0.318798 | \n0.324370 | \n-0.433065 | \n1.732260 | \n0.003799 | \n-0.015195 | \n
| 3.0 | \n0.350581 | \n0.350594 | \n0.348595 | \n0.350533 | \n0.358527 | \n-0.566611 | \n2.266446 | \n0.003455 | \n-0.013820 | \n
| 4.0 | \n0.176308 | \n0.176296 | \n0.178537 | \n0.176357 | \n0.167393 | \n1.264084 | \n-5.056334 | \n-0.006870 | \n0.027480 | \n
| 5.0 | \n0.114438 | \n0.114402 | \n0.115673 | \n0.114583 | \n0.109496 | \n1.079594 | \n-4.318374 | \n-0.031753 | \n0.127011 | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \n
|---|---|---|---|---|---|---|---|---|---|
| longitude | \n1.000000 | \n-0.924478 | \n-0.105848 | \n0.048871 | \n0.076598 | \n0.108030 | \n0.063070 | \n-0.019583 | \n-0.047432 | \n
| latitude | \n-0.924478 | \n1.000000 | \n0.005766 | \n-0.039184 | \n-0.072419 | \n-0.115222 | \n-0.077647 | \n-0.075205 | \n-0.142724 | \n
| housing_median_age | \n-0.105848 | \n0.005766 | \n1.000000 | \n-0.364509 | \n-0.325047 | \n-0.298710 | \n-0.306428 | \n-0.111360 | \n0.114110 | \n
| total_rooms | \n0.048871 | \n-0.039184 | \n-0.364509 | \n1.000000 | \n0.929379 | \n0.855109 | \n0.918392 | \n0.200087 | \n0.135097 | \n
| total_bedrooms | \n0.076598 | \n-0.072419 | \n-0.325047 | \n0.929379 | \n1.000000 | \n0.876320 | \n0.980170 | \n-0.009740 | \n0.047689 | \n
| population | \n0.108030 | \n-0.115222 | \n-0.298710 | \n0.855109 | \n0.876320 | \n1.000000 | \n0.904637 | \n0.002380 | \n-0.026920 | \n
| households | \n0.063070 | \n-0.077647 | \n-0.306428 | \n0.918392 | \n0.980170 | \n0.904637 | \n1.000000 | \n0.010781 | \n0.064506 | \n
| median_income | \n-0.019583 | \n-0.075205 | \n-0.111360 | \n0.200087 | \n-0.009740 | \n0.002380 | \n0.010781 | \n1.000000 | \n0.687160 | \n
| median_house_value | \n-0.047432 | \n-0.142724 | \n0.114110 | \n0.135097 | \n0.047689 | \n-0.026920 | \n0.064506 | \n0.687160 | \n1.000000 | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nocean_proximity | \n
|---|---|---|---|---|---|---|---|---|---|
| 17606 | \n-121.89 | \n37.29 | \n38.0 | \n1568.0 | \n351.0 | \n710.0 | \n339.0 | \n2.7042 | \n<1H OCEAN | \n
| 18632 | \n-121.93 | \n37.05 | \n14.0 | \n679.0 | \n108.0 | \n306.0 | \n113.0 | \n6.4214 | \n<1H OCEAN | \n
| 14650 | \n-117.20 | \n32.77 | \n31.0 | \n1952.0 | \n471.0 | \n936.0 | \n462.0 | \n2.8621 | \nNEAR OCEAN | \n
| 3230 | \n-119.61 | \n36.31 | \n25.0 | \n1847.0 | \n371.0 | \n1460.0 | \n353.0 | \n1.8839 | \nINLAND | \n
| 3555 | \n-118.59 | \n34.23 | \n17.0 | \n6592.0 | \n1525.0 | \n4459.0 | \n1463.0 | \n3.0347 | \n<1H OCEAN | \n
| ... | \n... | \n... | \n... | \n... | \n... | \n... | \n... | \n... | \n... | \n
| 6563 | \n-118.13 | \n34.20 | \n46.0 | \n1271.0 | \n236.0 | \n573.0 | \n210.0 | \n4.9312 | \nINLAND | \n
| 12053 | \n-117.56 | \n33.88 | \n40.0 | \n1196.0 | \n294.0 | \n1052.0 | \n258.0 | \n2.0682 | \nINLAND | \n
| 13908 | \n-116.40 | \n34.09 | \n9.0 | \n4855.0 | \n872.0 | \n2098.0 | \n765.0 | \n3.2723 | \nINLAND | \n
| 11159 | \n-118.01 | \n33.82 | \n31.0 | \n1960.0 | \n380.0 | \n1356.0 | \n356.0 | \n4.0625 | \n<1H OCEAN | \n
| 15775 | \n-122.45 | \n37.77 | \n52.0 | \n3095.0 | \n682.0 | \n1269.0 | \n639.0 | \n3.5750 | \nNEAR BAY | \n
16512 rows × 9 columns
\n| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nocean_proximity | \n
|---|---|---|---|---|---|---|---|---|---|
| 17606 | \n-121.89 | \n37.29 | \n38.0 | \n1568.0 | \n351.0 | \n710.0 | \n339.0 | \n2.7042 | \n<1H OCEAN | \n
| 18632 | \n-121.93 | \n37.05 | \n14.0 | \n679.0 | \n108.0 | \n306.0 | \n113.0 | \n6.4214 | \n<1H OCEAN | \n
| 14650 | \n-117.20 | \n32.77 | \n31.0 | \n1952.0 | \n471.0 | \n936.0 | \n462.0 | \n2.8621 | \nNEAR OCEAN | \n
| 3230 | \n-119.61 | \n36.31 | \n25.0 | \n1847.0 | \n371.0 | \n1460.0 | \n353.0 | \n1.8839 | \nINLAND | \n
| 3555 | \n-118.59 | \n34.23 | \n17.0 | \n6592.0 | \n1525.0 | \n4459.0 | \n1463.0 | \n3.0347 | \n<1H OCEAN | \n
| ... | \n... | \n... | \n... | \n... | \n... | \n... | \n... | \n... | \n... | \n
| 6563 | \n-118.13 | \n34.20 | \n46.0 | \n1271.0 | \n236.0 | \n573.0 | \n210.0 | \n4.9312 | \nINLAND | \n
| 12053 | \n-117.56 | \n33.88 | \n40.0 | \n1196.0 | \n294.0 | \n1052.0 | \n258.0 | \n2.0682 | \nINLAND | \n
| 13908 | \n-116.40 | \n34.09 | \n9.0 | \n4855.0 | \n872.0 | \n2098.0 | \n765.0 | \n3.2723 | \nINLAND | \n
| 11159 | \n-118.01 | \n33.82 | \n31.0 | \n1960.0 | \n380.0 | \n1356.0 | \n356.0 | \n4.0625 | \n<1H OCEAN | \n
| 15775 | \n-122.45 | \n37.77 | \n52.0 | \n3095.0 | \n682.0 | \n1269.0 | \n639.0 | \n3.5750 | \nNEAR BAY | \n
16512 rows × 9 columns
\n| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \n
|---|---|---|---|---|---|---|---|---|---|
| longitude | \n1.000000 | \n-0.924478 | \n-0.105848 | \n0.048871 | \n0.076598 | \n0.108030 | \n0.063070 | \n-0.019583 | \n-0.047432 | \n
| latitude | \n-0.924478 | \n1.000000 | \n0.005766 | \n-0.039184 | \n-0.072419 | \n-0.115222 | \n-0.077647 | \n-0.075205 | \n-0.142724 | \n
| housing_median_age | \n-0.105848 | \n0.005766 | \n1.000000 | \n-0.364509 | \n-0.325047 | \n-0.298710 | \n-0.306428 | \n-0.111360 | \n0.114110 | \n
| total_rooms | \n0.048871 | \n-0.039184 | \n-0.364509 | \n1.000000 | \n0.929379 | \n0.855109 | \n0.918392 | \n0.200087 | \n0.135097 | \n
| total_bedrooms | \n0.076598 | \n-0.072419 | \n-0.325047 | \n0.929379 | \n1.000000 | \n0.876320 | \n0.980170 | \n-0.009740 | \n0.047689 | \n
| population | \n0.108030 | \n-0.115222 | \n-0.298710 | \n0.855109 | \n0.876320 | \n1.000000 | \n0.904637 | \n0.002380 | \n-0.026920 | \n
| households | \n0.063070 | \n-0.077647 | \n-0.306428 | \n0.918392 | \n0.980170 | \n0.904637 | \n1.000000 | \n0.010781 | \n0.064506 | \n
| median_income | \n-0.019583 | \n-0.075205 | \n-0.111360 | \n0.200087 | \n-0.009740 | \n0.002380 | \n0.010781 | \n1.000000 | \n0.687160 | \n
| median_house_value | \n-0.047432 | \n-0.142724 | \n0.114110 | \n0.135097 | \n0.047689 | \n-0.026920 | \n0.064506 | \n0.687160 | \n1.000000 | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \nocean_proximity | \n
|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n-122.23 | \n37.88 | \n41.0 | \n880.0 | \n129.0 | \n322.0 | \n126.0 | \n8.3252 | \n452600.0 | \nNEAR BAY | \n
| 1 | \n-122.22 | \n37.86 | \n21.0 | \n7099.0 | \n1106.0 | \n2401.0 | \n1138.0 | \n8.3014 | \n358500.0 | \nNEAR BAY | \n
| 2 | \n-122.24 | \n37.85 | \n52.0 | \n1467.0 | \n190.0 | \n496.0 | \n177.0 | \n7.2574 | \n352100.0 | \nNEAR BAY | \n
| 3 | \n-122.25 | \n37.85 | \n52.0 | \n1274.0 | \n235.0 | \n558.0 | \n219.0 | \n5.6431 | \n341300.0 | \nNEAR BAY | \n
| 4 | \n-122.25 | \n37.85 | \n52.0 | \n1627.0 | \n280.0 | \n565.0 | \n259.0 | \n3.8462 | \n342200.0 | \nNEAR BAY | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \n
|---|---|---|---|---|---|---|---|---|---|
| count | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n20433.000000 | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n20640.000000 | \n
| mean | \n-119.569704 | \n35.631861 | \n28.639486 | \n2635.763081 | \n537.870553 | \n1425.476744 | \n499.539680 | \n3.870671 | \n206855.816909 | \n
| std | \n2.003532 | \n2.135952 | \n12.585558 | \n2181.615252 | \n421.385070 | \n1132.462122 | \n382.329753 | \n1.899822 | \n115395.615874 | \n
| min | \n-124.350000 | \n32.540000 | \n1.000000 | \n2.000000 | \n1.000000 | \n3.000000 | \n1.000000 | \n0.499900 | \n14999.000000 | \n
| 25% | \n-121.800000 | \n33.930000 | \n18.000000 | \n1447.750000 | \n296.000000 | \n787.000000 | \n280.000000 | \n2.563400 | \n119600.000000 | \n
| 50% | \n-118.490000 | \n34.260000 | \n29.000000 | \n2127.000000 | \n435.000000 | \n1166.000000 | \n409.000000 | \n3.534800 | \n179700.000000 | \n
| 75% | \n-118.010000 | \n37.710000 | \n37.000000 | \n3148.000000 | \n647.000000 | \n1725.000000 | \n605.000000 | \n4.743250 | \n264725.000000 | \n
| max | \n-114.310000 | \n41.950000 | \n52.000000 | \n39320.000000 | \n6445.000000 | \n35682.000000 | \n6082.000000 | \n15.000100 | \n500001.000000 | \n
| \n | Overall | \nStratified tr | \nRandom tr | \nStratified ts | \nRandom ts | \nRand. tr %error | \nRand. ts %error | \nStrat. tr %error | \nStrat. ts %error | \n
|---|---|---|---|---|---|---|---|---|---|
| 1.0 | \n0.039826 | \n0.039850 | \n0.039729 | \n0.039729 | \n0.040213 | \n-0.243309 | \n0.973236 | \n0.060827 | \n-0.243309 | \n
| 2.0 | \n0.318847 | \n0.318859 | \n0.317466 | \n0.318798 | \n0.324370 | \n-0.433065 | \n1.732260 | \n0.003799 | \n-0.015195 | \n
| 3.0 | \n0.350581 | \n0.350594 | \n0.348595 | \n0.350533 | \n0.358527 | \n-0.566611 | \n2.266446 | \n0.003455 | \n-0.013820 | \n
| 4.0 | \n0.176308 | \n0.176296 | \n0.178537 | \n0.176357 | \n0.167393 | \n1.264084 | \n-5.056334 | \n-0.006870 | \n0.027480 | \n
| 5.0 | \n0.114438 | \n0.114402 | \n0.115673 | \n0.114583 | \n0.109496 | \n1.079594 | \n-4.318374 | \n-0.031753 | \n0.127011 | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nmedian_house_value | \n
|---|---|---|---|---|---|---|---|---|---|
| longitude | \n1.000000 | \n-0.924478 | \n-0.105848 | \n0.048871 | \n0.076598 | \n0.108030 | \n0.063070 | \n-0.019583 | \n-0.047432 | \n
| latitude | \n-0.924478 | \n1.000000 | \n0.005766 | \n-0.039184 | \n-0.072419 | \n-0.115222 | \n-0.077647 | \n-0.075205 | \n-0.142724 | \n
| housing_median_age | \n-0.105848 | \n0.005766 | \n1.000000 | \n-0.364509 | \n-0.325047 | \n-0.298710 | \n-0.306428 | \n-0.111360 | \n0.114110 | \n
| total_rooms | \n0.048871 | \n-0.039184 | \n-0.364509 | \n1.000000 | \n0.929379 | \n0.855109 | \n0.918392 | \n0.200087 | \n0.135097 | \n
| total_bedrooms | \n0.076598 | \n-0.072419 | \n-0.325047 | \n0.929379 | \n1.000000 | \n0.876320 | \n0.980170 | \n-0.009740 | \n0.047689 | \n
| population | \n0.108030 | \n-0.115222 | \n-0.298710 | \n0.855109 | \n0.876320 | \n1.000000 | \n0.904637 | \n0.002380 | \n-0.026920 | \n
| households | \n0.063070 | \n-0.077647 | \n-0.306428 | \n0.918392 | \n0.980170 | \n0.904637 | \n1.000000 | \n0.010781 | \n0.064506 | \n
| median_income | \n-0.019583 | \n-0.075205 | \n-0.111360 | \n0.200087 | \n-0.009740 | \n0.002380 | \n0.010781 | \n1.000000 | \n0.687160 | \n
| median_house_value | \n-0.047432 | \n-0.142724 | \n0.114110 | \n0.135097 | \n0.047689 | \n-0.026920 | \n0.064506 | \n0.687160 | \n1.000000 | \n
| \n | longitude | \nlatitude | \nhousing_median_age | \ntotal_rooms | \ntotal_bedrooms | \npopulation | \nhouseholds | \nmedian_income | \nocean_proximity | \nrooms_per_household | \nbedrooms_per_household | \npopulation_per_household | \nbedrooms_per_rooms | \n
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \n-121.89 | \n37.29 | \n38 | \n1568 | \n351 | \n710 | \n339 | \n2.7042 | \n<1H OCEAN | \n4.62537 | \n1.0354 | \n2.0944 | \n0.223852 | \n
| 1 | \n-121.93 | \n37.05 | \n14 | \n679 | \n108 | \n306 | \n113 | \n6.4214 | \n<1H OCEAN | \n6.00885 | \n0.955752 | \n2.70796 | \n0.159057 | \n
| 2 | \n-117.2 | \n32.77 | \n31 | \n1952 | \n471 | \n936 | \n462 | \n2.8621 | \nNEAR OCEAN | \n4.22511 | \n1.01948 | \n2.02597 | \n0.241291 | \n
| 3 | \n-119.61 | \n36.31 | \n25 | \n1847 | \n371 | \n1460 | \n353 | \n1.8839 | \nINLAND | \n5.23229 | \n1.05099 | \n4.13598 | \n0.200866 | \n
| 4 | \n-118.59 | \n34.23 | \n17 | \n6592 | \n1525 | \n4459 | \n1463 | \n3.0347 | \n<1H OCEAN | \n4.50581 | \n1.04238 | \n3.04785 | \n0.231341 | \n
| 在 TensorFlow.org 上查看\n | \n在 Google Colab 运行\n | \n在 Github 上查看源代码\n | \n下载笔记本 | \n
This shows the Huber weight function, $W_2(x)$ and some cartoon data points that are insiders or outsiders as far as the robust location estimate is concerned.
\n\n\n\n\n\n### Breakdown Point\n\nSo far, our discussion of robustness has been very abstract. A more concrete\nconcept of robustness comes from the breakdown point. In the simplest terms,\nthe breakdown point describes what happens when a single data point in an\nestimator is changed in the most damaging way possible. For example, suppose we\nhave the sample mean, $\\hat{\\mu}=\\sum x_i/n$, and we take one of the $x_i$\npoints to be infinite. What happens to this estimator? It also goes infinite.\nThis means that the breakdown point of the estimator is 0%. On the other hand,\nthe median has a breakdown point of 50%, meaning that half of the data for\ncomputing the median could go infinite without affecting the median value. The median\nis a *rank* statistic that cares more about the relative ranking of the data\nthan the values of the data, which explains its robustness.\n\nThe simpliest but still formal way to express the breakdown point is to\ntake $n$ data points, $\\mathcal{D} = \\lbrace (x_i,y_i) \\rbrace$. Suppose $T$\nis a regression estimator that yields a vector of regression coefficients,\n$\\boldsymbol{\\theta}$,\n\n$$\nT(\\mathcal{D}) = \\boldsymbol{\\theta}\n$$\n\n Likewise, consider all possible corrupted samples of the data\n$\\mathcal{D}^\\prime$. The maximum *bias* caused by this contamination is\nthe following:\n\n$$\n\\texttt{bias}_{m} = \\sup_{\\mathcal{D}^\\prime} \\Vert T(\\mathcal{D^\\prime})-T(\\mathcal{D}) \\Vert\n$$\n\n where the $\\sup$ sweeps over all possible sets of $m$ contaminated samples.\nUsing this, the breakdown point is defined as the following:\n\n$$\n\\epsilon_m = \\min \\Big\\lbrace \\frac{m}{n} \\colon \\texttt{bias}_{m} \\rightarrow \\infty \\Big\\rbrace\n$$\n\n For example, in our least-squares regression, even one point at\ninfinity causes an infinite $T$. Thus, for least-squares regression,\n$\\epsilon_m=1/n$. In the limit $n \\rightarrow \\infty$, we have $\\epsilon_m\n\\rightarrow 0$.\n\n### Estimating Scale\n\nIn robust statistics, the concept of *scale* refers to a measure of the\ndispersion of the data. Usually, we use the\nestimated standard deviation for this, but this has a terrible breakdown point.\nEven more troubling, in order to get a good estimate of location, we have to\neither somehow know the scale ahead of time, or jointly estimate it. None of\nthese methods have easy-to-compute closed form solutions and must be computed\nnumerically.\n\nThe most popular method for estimating scale is the *median absolute deviation*\n\n$$\n\\texttt{MAD} = \\texttt{Med} (\\vert \\mathbf{x} - \\texttt{Med}(\\mathbf{x})\\vert)\n$$\n\n In words, take the median of the data $\\mathbf{x}$ and\nthen subtract that median from the data itself, and then take the median of the\nabsolute value of the result. Another good dispersion estimate is the *interquartile range*,\n\n$$\n\\texttt{IQR} = x_{(n-m+1)} - x_{(n)}\n$$\n\n where $m= [n/4]$. The $x_{(n)}$ notation means the $n^{th}$ data\nelement after the data have been sorted. Thus, in this notation,\n$\\texttt{max}(\\mathbf{x})=x_{(n)}$. In the case where $x \\sim\n\\mathcal{N}(\\mu,\\sigma^2)$, then $\\texttt{MAD}$ and $\\texttt{IQR}$ are constant\nmultiples of $\\sigma$ such that the normalized $\\texttt{MAD}$ is the following,\n\n$$\n\\texttt{MADN}(x) = \\frac{\\texttt{MAD} }{0.675}\n$$\n\n The number comes from the inverse CDF of the normal distribution\ncorresponding to the $0.75$ level. Given the complexity of the\ncalculations, *jointly* estimating both location and scale is a purely\nnumerical matter. Fortunately, the Statsmodels module has many of these\nready to use. Let's create some contaminated data in the following code,\n\n\n```python\nimport statsmodels.api as sm\nfrom scipy import stats\ndata=np.hstack([stats.norm(10,1).rvs(10),stats.norm(0,1).rvs(100)])\n```\n\n These data correspond to our model of contamination that we started\nthis section with. As shown in the histogram in [Figure](#fig:Robust_Statistics_0002), there are two normal distributions, one\ncentered neatly at zero, representing the majority of the samples, and another\ncoming less regularly from the normal distribution on the right. Notice that\nthe group of infrequent samples on the right separates the mean and median\nestimates (vertical dotted and dashed lines). In the absence of the\ncontaminating distribution on the right, the standard deviation for this data\nshould be close to one. However, the usual non-robust estimate for standard\ndeviation (`np.std`) comes out to approximately three. Using the\n$\\texttt{MADN}$ estimator (`sm.robust.scale.mad(data)`) we obtain approximately\n1.25. Thus, the robust estimate of dispersion is less moved by the presence of\nthe contaminating distribution.\n\n\n\n\n\nHistogram of sample data. Notice that the group of infrequent samples on the right separates the mean and median estimates indicated by the vertical lines.
\n\n\n\n\n\nThe generalized maximum likelihood M-estimation extends to joint\nscale and location estimation using Huber functions. For example,\n\n\n```python\nhuber = sm.robust.scale.Huber()\nloc,scl=huber(data)\n```\n\n which implements Huber's *proposal two* method of joint estimation of\nlocation and scale. This kind of estimation is the key ingredient to robust\nregression methods, many of which are implemented in Statsmodels in\n`statsmodels.formula.api.rlm`. The corresponding documentation has more\ninformation.\n", "meta": {"hexsha": "b452d76173f6c4a864c7634fd4b8f88d787c14df", "size": 140181, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapters/statistics/notebooks/Robust_Statistics.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/Robust_Statistics.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/Robust_Statistics.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": 184.4486842105, "max_line_length": 114721, "alphanum_fraction": 0.8922179183, "converted": true, "num_tokens": 4580, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3557748935136303, "lm_q2_score": 0.2568319856991699, "lm_q1q2_score": 0.09137437236301638}} {"text": "```python\nfrom IPython.display import HTML\n\nHTML('''\n''')\n```\n\n\n\n\n\n\n\n\n\n\n```javascript\n%%javascript\n MathJax.Hub.Config({\n TeX: { equationNumbers: { autoNumber: \"AMS\" } }\n });\n```\n\n\n| \n | B | \nIXY | \nIXZ | \nIYY | \nIYZ | \nIZZ | \nKXX | \nKXY | \nKYY | \nKZZ | \nLPP | \nS | \nV | \nXCG | \nYCG | \nZCG | \naccx | \nacto | \nb1c | \nb1cr | \nb1l | \nb1q | \nb2c | \nb2cr | \nb2l | \nb2q | \nb3c | \nb3cr | \nb3l | \nb3q | \nb4c | \nb4cr | \nb4l | \nb4q | \nb5c | \nb5cr | \nb5l | \nb5q | \nb6c | \nb6cr | \nb6l | \nb6q | \nbdens | \nbody | \nclev | \nclevel | \ncurv | \ndens | \ndensi | \ndofa | \ndofactor | \ndopa | \ndopadding | \ndopo | \ndopower | \ndown | \ndowns | \ndownst | \ndt | \nfile | \nfile_path_ts | \nfn | \nform | \nfree | \ngravi | \nheave | \nheel | \nhull | \ninter | \nk1nd | \nk2nd | \nk3nd | \nk4nd | \nk5nd | \nk6nd | \nkxx | \nkyy | \nleve | \nlevel | \nlpp | \nm | \nmaxti | \nmaxtime | \nmesh | \nname | \nnpxp | \nnpyp | \nnstep | \nnthr | \npitch | \npowe | \npower | \nrefle | \nreflen | \nrn | \nroll | \nrud1 | \nrud2 | \nrud3 | \nrud4 | \nrud5 | \nrud6 | \nrudt | \nside | \nslim | \nstre | \nstrength | \nsurge | \nsway | \nta | \ntf | \ntfnhi | \ntfnhigh | \ntfnlo | \ntfnlow | \ntitl | \ntitle | \ntrim | \nupst | \nupstr | \nvm_s | \nwlin | \nwlme | \nyaw | \nymax | \nymin | \nzcg | \nconv | \nencounters | \nid | \n
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| kvlcc2_rolldecay_0kn | \n0.853 | \n0.0 | \n0.0 | \n26.055 | \n0.0 | \n26.055 | \n0.341 | \n7.556 | \n1.177 | \n1.177 | \n4.706 | \n5.981 | \n0.993 | \n2.519 | \n0.0 | \n0.274 | \n0.050 | \n1.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.00000 | \n0.00000 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.6 | \n0.3 | \n6.0 | \n6.0 | \n0.00002 | \n1000.0 | \n1000.0 | \n50.0 | \n50.0 | \n2.0 | \n2.0 | \n2.0 | \n2.0 | \n1.00 | \n-5.0 | \n1.00 | \n0.02 | \n.. | \nC:\\Dev\\Prediction-of-roll-damping-using-fully-... | \n1.472020e-07 | \n0.23 | \n0.3 | \n9.80665 | \n0.0 | \n0.0 | \n0.002 | \n0.000000e+00 | \n0.1 | \n0.1 | \n0.0 | \n0.0 | \n0.0 | \n0.1 | \n0.341185 | \n1.1765 | \n6.0 | \n6.0 | \n4.706 | \n993.42 | \n180.0 | \n180.0 | \n0.000000e+00 | \nTRAN | \n40.0 | \n40.0 | \n30.0 | \n32.0 | \n0.0 | \n2.0 | \n2.0 | \n4.706 | \n4.706 | \n3.957280e+00 | \n10.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n1.00 | \n30.0 | \n0.50 | \n0.50 | \n0.0 | \n0.0 | \n0.3059 | \n0.3059 | \n4.0 | \n4.0 | \n0.5 | \n0.5 | \nKVLCC2 | \nKVLCC2 | \n0.0 | \n1.00 | \n5.0 | \n0.000001 | \n0.000001 | \n0.000001 | \n0.0 | \n5.0 | \n-5.0 | \n0.2735 | \nNaN | \nNaN | \n21338.0 | \n
| kvlcc2_rolldecay_15-5kn_const_large2 | \n0.853 | \n0.0 | \n0.0 | \n26.055 | \n0.0 | \n26.055 | \n0.341 | \n7.556 | \n1.177 | \n1.177 | \n4.706 | \n5.981 | \n0.993 | \n2.519 | \n0.0 | \n0.274 | \n0.025 | \n1.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.00000 | \n0.00000 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.6 | \n0.3 | \n6.0 | \n6.0 | \n0.00002 | \n1000.0 | \n1000.0 | \n1.0 | \n1.0 | \n2.0 | \n2.0 | \n1.0 | \n1.0 | \n0.70 | \n-5.0 | \n0.70 | \n0.02 | \n.. | \nC:\\Dev\\Prediction-of-roll-damping-using-fully-... | \n1.423410e-01 | \n0.23 | \n0.3 | \n9.80665 | \n0.0 | \n0.0 | \n0.002 | \n0.000000e+00 | \n0.1 | \n0.1 | \n0.0 | \n0.0 | \n0.0 | \n0.1 | \n0.341185 | \n1.1765 | \n6.0 | \n6.0 | \n4.706 | \n993.42 | \n200.0 | \n200.0 | \n0.000000e+00 | \nTRAN | \n40.0 | \n40.0 | \n30.0 | \n32.0 | \n0.0 | \n2.0 | \n2.0 | \n4.706 | \n4.706 | \n3.826600e+06 | \n10.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.70 | \n30.0 | \n0.05 | \n0.05 | \n0.0 | \n0.0 | \n0.3059 | \n0.3059 | \n4.0 | \n4.0 | \n0.5 | \n0.5 | \nKVLCC2 | \nKVLCC2 | \n0.0 | \n0.70 | \n5.0 | \n0.966976 | \n0.000001 | \n0.000001 | \n0.0 | \n5.0 | \n-5.0 | \n0.2735 | \nNaN | \nNaN | \n21340.0 | \n
| kvlcc2_rolldecay_15-5kn_ikeda_dev | \n0.853 | \n0.0 | \n0.0 | \n26.055 | \n0.0 | \n26.055 | \n0.341 | \n7.556 | \n1.177 | \n1.177 | \n4.706 | \n5.981 | \n0.993 | \n2.519 | \n0.0 | \n0.274 | \n0.050 | \n1.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n6.07217 | \n2.74371 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.0 | \n1.0 | \n0.0 | \n0.0 | \n0.6 | \n0.3 | \n6.0 | \n6.0 | \n0.00004 | \n1000.0 | \n1000.0 | \n0.0 | \n0.0 | \n2.0 | \n2.0 | \n1.0 | \n1.0 | \n0.25 | \n-2.0 | \n0.25 | \nNaN | \n.. | \nC:\\Dev\\Prediction-of-roll-damping-using-fully-... | \n1.423410e-01 | \n0.20 | \n0.3 | \n9.80665 | \n0.0 | \n0.0 | \n0.002 | \n1.000000e-07 | \n0.1 | \n0.1 | \n0.0 | \n0.0 | \n0.0 | \n0.1 | \n0.341185 | \n1.1765 | \n6.0 | \n6.0 | \n4.706 | \n993.42 | \n600.0 | \n600.0 | \n1.000000e-07 | \nTRAN | \n24.0 | \n24.0 | \n30.0 | \n6.0 | \n0.0 | \n2.0 | \n2.0 | \n4.706 | \n4.706 | \n3.826600e+06 | \n10.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.0 | \n0.25 | \n30.0 | \n1.00 | \n1.00 | \n0.0 | \n0.0 | \n0.3059 | \n0.3059 | \n4.0 | \n4.0 | \n0.5 | \n0.5 | \nKVLCC2 | \nKVLCC2 | \n0.0 | \n0.25 | \n2.0 | \n0.966976 | \n0.000001 | \n0.000001 | \n0.0 | \n2.0 | \n-2.0 | \n0.2735 | \n0.0001 | \n0.0 | \n21340.0 | \n
| \n | area | \nx | \nt | \nb | \nr_b | \n
|---|---|---|---|---|---|
| no | \n\n | \n | \n | \n | \n |
| 0 | \n13.826612 | \n-5.495000 | \n2.00 | \n11.638577 | \n6.636080 | \n
| 1 | \n123.851306 | \n10.159932 | \n18.25 | \n27.893522 | \n42.367175 | \n
| 2 | \n428.211409 | \n28.051284 | \n20.80 | \n41.824284 | \n45.369454 | \n
| 3 | \n683.709165 | \n43.706216 | \n20.80 | \n50.282514 | \n41.080696 | \n
| 4 | \n917.895066 | \n61.597568 | \n20.80 | \n56.159232 | \n34.146143 | \n
| \n | Province/State | \nCountry/Region | \nLat | \nLong | \n1/22/20 | \n1/23/20 | \n1/24/20 | \n1/25/20 | \n1/26/20 | \n1/27/20 | \n... | \n5/24/20 | \n5/25/20 | \n5/26/20 | \n5/27/20 | \n5/28/20 | \n5/29/20 | \n5/30/20 | \n5/31/20 | \n6/1/20 | \n6/2/20 | \n
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | \nNaN | \nAfghanistan | \n33.0000 | \n65.0000 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n10582 | \n11173 | \n11831 | \n12456 | \n13036 | \n13659 | \n14525 | \n15205 | \n15750 | \n16509 | \n
| 1 | \nNaN | \nAlbania | \n41.1533 | \n20.1683 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n998 | \n1004 | \n1029 | \n1050 | \n1076 | \n1099 | \n1122 | \n1137 | \n1143 | \n1164 | \n
| 2 | \nNaN | \nAlgeria | \n28.0339 | \n1.6596 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n8306 | \n8503 | \n8697 | \n8857 | \n8997 | \n9134 | \n9267 | \n9394 | \n9513 | \n9626 | \n
| 3 | \nNaN | \nAndorra | \n42.5063 | \n1.5218 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n762 | \n763 | \n763 | \n763 | \n763 | \n764 | \n764 | \n764 | \n765 | \n844 | \n
| 4 | \nNaN | \nAngola | \n-11.2027 | \n17.8739 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n69 | \n70 | \n70 | \n71 | \n74 | \n81 | \n84 | \n86 | \n86 | \n86 | \n
5 rows × 137 columns
\n| \n | Province/State | \nCountry/Region | \nLat | \nLong | \n1/22/20 | \n1/23/20 | \n1/24/20 | \n1/25/20 | \n1/26/20 | \n1/27/20 | \n... | \n5/24/20 | \n5/25/20 | \n5/26/20 | \n5/27/20 | \n5/28/20 | \n5/29/20 | \n5/30/20 | \n5/31/20 | \n6/1/20 | \n6/2/20 | \n
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 217 | \nBermuda | \nUnited Kingdom | \n32.3078 | \n-64.7505 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n133 | \n133 | \n139 | \n139 | \n140 | \n140 | \n140 | \n140 | \n141 | \n141 | \n
| 218 | \nCayman Islands | \nUnited Kingdom | \n19.3133 | \n-81.2546 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n129 | \n134 | \n137 | \n140 | \n140 | \n141 | \n141 | \n141 | \n150 | \n151 | \n
| 219 | \nChannel Islands | \nUnited Kingdom | \n49.3723 | \n-2.3644 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n558 | \n559 | \n559 | \n560 | \n560 | \n560 | \n560 | \n560 | \n560 | \n560 | \n
| 220 | \nGibraltar | \nUnited Kingdom | \n36.1408 | \n-5.3536 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n154 | \n154 | \n154 | \n157 | \n158 | \n161 | \n169 | \n170 | \n170 | \n172 | \n
| 221 | \nIsle of Man | \nUnited Kingdom | \n54.2361 | \n-4.5481 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n336 | \n336 | \n336 | \n336 | \n336 | \n336 | \n336 | \n336 | \n336 | \n336 | \n
| 222 | \nMontserrat | \nUnited Kingdom | \n16.7425 | \n-62.1874 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n11 | \n11 | \n11 | \n11 | \n11 | \n11 | \n11 | \n11 | \n11 | \n11 | \n
| 223 | \nNaN | \nUnited Kingdom | \n55.3781 | \n-3.4360 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n259559 | \n261184 | \n265227 | \n267240 | \n269127 | \n271222 | \n272826 | \n274762 | \n276332 | \n277985 | \n
| 248 | \nAnguilla | \nUnited Kingdom | \n18.2206 | \n-63.0686 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n3 | \n3 | \n3 | \n3 | \n3 | \n3 | \n3 | \n3 | \n3 | \n3 | \n
| 249 | \nBritish Virgin Islands | \nUnited Kingdom | \n18.4207 | \n-64.6400 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n8 | \n8 | \n8 | \n8 | \n8 | \n8 | \n8 | \n8 | \n8 | \n8 | \n
| 250 | \nTurks and Caicos Islands | \nUnited Kingdom | \n21.6940 | \n-71.7979 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n12 | \n12 | \n12 | \n12 | \n12 | \n12 | \n12 | \n12 | \n12 | \n12 | \n
| 257 | \nFalkland Islands (Malvinas) | \nUnited Kingdom | \n-51.7963 | \n-59.5236 | \n0 | \n0 | \n0 | \n0 | \n0 | \n0 | \n... | \n13 | \n13 | \n13 | \n13 | \n13 | \n13 | \n13 | \n13 | \n13 | \n13 | \n
11 rows × 137 columns
\nFigure 1:
\n\n\nAnother useful Python package is\n[pandas](https://pandas.pydata.org/), which is an open source library\nproviding high-performance, easy-to-use data structures and data\nanalysis tools for Python. **pandas** stands for panel data, a term borrowed from econometrics and is an efficient library for data analysis with an emphasis on tabular data.\n\n**pandas** has two major classes, the **DataFrame** class with\ntwo-dimensional data objects and tabular data organized in columns and\nthe class **Series** with a focus on one-dimensional data objects. Both\nclasses allow you to index data easily as we will see in the examples\nbelow. **pandas** allows you also to perform mathematical operations on\nthe data, spanning from simple reshapings of vectors and matrices to\nstatistical operations.\n\nThe following simple example shows how we can, in an easy way make\ntables of our data. Here we define a data set which includes names,\nplace of birth and date of birth, and displays the data in an easy to\nread way. We will see repeated use of **pandas**, in particular in\nconnection with classification of data.\n\n\n```python\nimport pandas as pd\nfrom IPython.display import display\ndata = {'First Name': [\"Frodo\", \"Bilbo\", \"Aragorn II\", \"Samwise\"],\n 'Last Name': [\"Baggins\", \"Baggins\",\"Elessar\",\"Gamgee\"],\n 'Place of birth': [\"Shire\", \"Shire\", \"Eriador\", \"Shire\"],\n 'Date of Birth T.A.': [2968, 2890, 2931, 2980]\n }\ndata_pandas = pd.DataFrame(data)\ndisplay(data_pandas)\n```\n\nIn the above we have imported **pandas** with the shorthand **pd**, the latter has become the standard way we import **pandas**. We make then a list of various variables\nand reorganize the above lists into a **DataFrame** and then print out a neat table with specific column labels as *Name*, *place of birth* and *date of birth*.\nDisplaying these results, we see that the indices are given by the default numbers from zero to three.\n**pandas** is extremely flexible and we can easily change the above indices by defining a new type of indexing as\n\n\n```python\ndata_pandas = pd.DataFrame(data,index=['Frodo','Bilbo','Aragorn','Sam'])\ndisplay(data_pandas)\n```\n\nThereafter we display the content of the row which begins with the index **Aragorn**\n\n\n```python\ndisplay(data_pandas.loc['Aragorn'])\n```\n\nWe can easily append data to this, for example\n\n\n```python\nnew_hobbit = {'First Name': [\"Peregrin\"],\n 'Last Name': [\"Took\"],\n 'Place of birth': [\"Shire\"],\n 'Date of Birth T.A.': [2990]\n }\ndata_pandas=data_pandas.append(pd.DataFrame(new_hobbit, index=['Pippin']))\ndisplay(data_pandas)\n```\n\nHere are other examples where we use the **DataFrame** functionality to handle arrays, now with more interesting features for us, namely numbers. We set up a matrix \nof dimensionality $10\\times 5$ and compute the mean value and standard deviation of each column. Similarly, we can perform mathematial operations like squaring the matrix elements and many other operations.\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 matrix\nrows = 10\ncols = 5\na = np.random.randn(rows,cols)\ndf = pd.DataFrame(a)\ndisplay(df)\nprint(df.mean())\nprint(df.std())\ndisplay(df**2)\n```\n\nThereafter we can select specific columns only and plot final results\n\n\n```python\ndf.columns = ['First', 'Second', 'Third', 'Fourth', 'Fifth']\ndf.index = np.arange(10)\n\ndisplay(df)\nprint(df['Second'].mean() )\nprint(df.info())\nprint(df.describe())\n\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\ndf.cumsum().plot(lw=2.0, figsize=(10,6))\nplt.show()\n\n\ndf.plot.bar(figsize=(10,6), rot=15)\nplt.show()\n```\n\nWe can produce a $4\\times 4$ matrix\n\n\n```python\nb = np.arange(16).reshape((4,4))\nprint(b)\ndf1 = pd.DataFrame(b)\nprint(df1)\n```\n\nand many other operations. \n\nThe **Series** class is another important class included in\n**pandas**. You can view it as a specialization of **DataFrame** but where\nwe have just a single column of data. It shares many of the same\nfeatures as **DataFrame**. As with **DataFrame**, most operations are\nvectorized, achieving thereby a high performance when dealing with\ncomputations of arrays, in particular labeled arrays. As we will see\nbelow it leads also to a very concice code close to the mathematical\noperations we may be interested in. For multidimensional arrays, we\nrecommend strongly\n[xarray](http://xarray.pydata.org/en/stable/). **xarray** has much of\nthe same flexibility as **pandas**, but allows for the extension to\nhigher dimensions than two.\n\n## Introduction to Git and GitHub/GitLab and similar\n\n[Git](https://git-scm.com/) is a distributed version-control system\nfor tracking changes in any set of files, originally designed for\ncoordinating work among programmers cooperating on source code during\nsoftware development.\n\nThe [reference document and videos here](https://git-scm.com/doc)\ngive you an excellent introduction to the **git**.\n\nWe believe you will find version-control software very useful in your work.\n\n## GitHub, GitLab and many other\n\n[GitHub](https://github.com/), [GitLab](https://about.gitlab.com/), [Bitbucket](https://bitbucket.org/product?&aceid=&adposition=&adgroup=92266806717&campaign=1407243017&creative=414608923671&device=c&keyword=bitbucket&matchtype=e&network=g&placement=&ds_kids=p51241248597&ds_e=GOOGLE&ds_eid=700000001551985&ds_e1=GOOGLE&gclid=Cj0KCQiA6Or_BRC_ARIsAPzuer_yrxzs-R8KDVdF0-DduJR9hTBYcjdE8L9_CkA9eyz8XT7-3bFGOpQaAqe2EALw_wcB&gclsrc=aw.ds) and other are code hosting platforms for\nversion control and collaboration. They let you and others work\ntogether on projects from anywhere.\n\nAll teaching material related to this course is open and freely\navailable via the GitHub site of the course. The video here gives a\nshort intro to\n[GitHub](https://www.youtube.com/watch/w3jLJU7DT5E?reload=9).\n\nSee also the [overview video on Git and GitHub](https://mediaspace.msu.edu/media/t/1_8mgx3cyf).\n\n## Useful Git and GitHub links\n\nThese are a couple references that we have found useful (git commands, markdown, GitPages):\n*| \n | t[s] | \ny[m] | \nv[m/s] | \na[m/s^2] | \n
|---|---|---|---|---|
| 0 | \n0.0 | \n10.000000 | \n0.000000 | \n-9.80655 | \n
| 1 | \n0.1 | \n9.950967 | \n-1.470982 | \n-9.80655 | \n
| 2 | \n0.2 | \n9.803869 | \n-2.451638 | \n-9.80655 | \n
| 3 | \n0.3 | \n9.558705 | \n-3.432292 | \n-9.80655 | \n
| 4 | \n0.4 | \n9.215476 | \n-4.412948 | \n-9.80655 | \n
| 5 | \n0.5 | \n8.774181 | \n-5.393602 | \n-9.80655 | \n
| 6 | \n0.6 | \n8.234821 | \n-6.374258 | \n-9.80655 | \n
| 7 | \n0.7 | \n7.597395 | \n-7.354913 | \n-9.80655 | \n
| 8 | \n0.8 | \n6.861904 | \n-8.335567 | \n-9.80655 | \n
| 9 | \n0.9 | \n6.028347 | \n-9.316222 | \n-9.80655 | \n
| 10 | \n1.0 | \n5.096725 | \n-10.296878 | \n-9.80655 | \n
| 11 | \n1.1 | \n4.067037 | \n-11.277533 | \n-9.80655 | \n
| 12 | \n1.2 | \n2.939284 | \n-12.258187 | \n-9.80655 | \n
Failed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nThere is a problem with this: we haven't checked if the states on the curve can be *physically* connected to this point. That is, we haven't checked how the characteristic speed changes along the curve.\n\nHere it is obvious: we know that the characteristics must spread across the rarefaction, so $\\lambda$ must increase, and as $\\xi = \\lambda$ we must have the characteristic coordinate increasing.\n\n\n```python\ndef plot_sw_rarefaction_physical(hl, ul):\n \"Plot the rarefaction curve through the state (hl, ul)\"\n \n xil = ul - np.sqrt(hl)\n xi_physical = np.linspace(xil, xi_max)\n xi_unphysical = np.linspace(xi_min, xil)\n h_physical = ((xil - xi_physical) / 3.0 + np.sqrt(hl))**2\n u_physical = 2.0 * (xi_physical - xil) / 3.0 + ul\n h_unphysical = ((xil - xi_unphysical) / 3.0 + np.sqrt(hl))**2\n u_unphysical = 2.0 * (xi_unphysical - xil) / 3.0 + ul\n \n \n fig = plt.figure(figsize=(12,8))\n ax = fig.add_subplot(111)\n ax.plot(hl, ul, 'rx', markersize = 16, markeredgewidth = 3)\n ax.plot(h_physical, u_physical, 'k-', linewidth = 2, label=\"Physical\")\n ax.plot(h_unphysical, u_unphysical, 'k--', linewidth = 2, label=\"Unphysical\")\n ax.set_xlabel(r\"$h$\")\n ax.set_ylabel(r\"$u$\")\n dh = h_max - h_min\n du = u_max - u_min\n ax.set_xbound(h_min - 0.1 * dh, h_max + 0.1 * dh)\n ax.set_ybound(u_min - 0.1 * du, u_max + 0.1 * du)\n ax.legend()\n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_rarefaction_physical, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.0))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nWe see that along the physical part of the rarefaction curve the height $h$ decreases.\n\nInstead of writing the solution in terms of the similarity coordinate $\\xi$ we can instead write the solution in terms of any other single parameter. It is useful to write it in terms of the height, which can be done simply by re-arranging the equations giving $u$ and $h$ in terms of $\\xi$. So, a state with height $h_m$ to the right of the state $(h_l, u_l)$ can be connected across a rarefaction if\n$$\n u_m = u_l + 2 \\left( \\sqrt{h_l} - \\sqrt{h_m} \\right).\n$$\n\nIn this form we will look at the characteristic curves and the behaviour in state space to cross-check.\n\n\n```python\ndef plot_sw_rarefaction_physical_characteristics(hl, ul, hm):\n \"Plot the rarefaction curve through the state (hl, ul) finishing at (hm, um)\"\n \n um = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hm))\n \n h_maximum = np.max([h_max, hl, hm])\n h_minimum = np.min([h_min, hl, hm])\n u_maximum = np.max([u_max, ul, um])\n u_minimum = np.min([u_min, ul, um])\n dh = h_maximum - h_minimum\n du = u_maximum - u_minimum\n xi_min = u_minimum - np.sqrt(h_maximum)\n xi_max = u_maximum - np.sqrt(h_minimum)\n \n xil = ul - np.sqrt(hl)\n xim = um - np.sqrt(hm)\n xi_physical = np.linspace(xil, xi_max)\n xi_unphysical = np.linspace(xi_min, xil)\n h_physical = ((xil - xi_physical) / 3.0 + np.sqrt(hl))**2\n u_physical = 2.0 * (xi_physical - xil) / 3.0 + ul\n h_unphysical = ((xil - xi_unphysical) / 3.0 + np.sqrt(hl))**2\n u_unphysical = 2.0 * (xi_unphysical - xil) / 3.0 + ul\n \n \n fig = plt.figure(figsize=(12,8))\n ax1 = fig.add_subplot(121)\n ax1.plot(hl, ul, 'rx', markersize = 16, markeredgewidth = 3, label=r\"$(h_l, u_l)$\")\n ax1.plot(hm, um, 'b+', markersize = 16, markeredgewidth = 3, label=r\"$(h_m, u_m)$\")\n ax1.plot(h_physical, u_physical, 'k-', linewidth = 2, label=\"Physical\")\n ax1.plot(h_unphysical, u_unphysical, 'k--', linewidth = 2, label=\"Unphysical\")\n ax1.set_xlabel(r\"$h$\")\n ax1.set_ylabel(r\"$u$\")\n ax1.set_xbound(h_minimum - 0.1 * dh, h_maximum + 0.1 * dh)\n ax1.set_ybound(u_minimum - 0.1 * du, u_maximum + 0.1 * du)\n ax1.legend()\n \n ax2 = fig.add_subplot(122)\n left_edge = np.min([-1.0, -1.0 - xil])\n right_edge = np.max([1.0, 1.0 - xim])\n x_start_points_l = np.linspace(left_edge, 0.0, 20)\n x_start_points_r = np.linspace(0.0, right_edge, 20)\n x_end_points_l = x_start_points_l + xil\n x_end_points_r = x_start_points_r + xim\n \n for xs, xe in zip(x_start_points_l, x_end_points_l):\n ax2.plot([xs, xe], [0.0, 1.0], 'b-')\n for xs, xe in zip(x_start_points_r, x_end_points_r):\n ax2.plot([xs, xe], [0.0, 1.0], 'g-')\n \n # Rarefaction wave\n if (xim > xil):\n xi = np.linspace(xil, xim, 11)\n x_end_rarefaction = xi\n for xe in x_end_rarefaction:\n ax2.plot([0.0, xe], [0.0, 1.0], 'r--')\n else:\n x_fill = [x_end_points_l[-1], x_start_points_l[-1], x_end_points_r[0]]\n t_fill = [1.0, 0.0, 1.0]\n ax2.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n ax2.set_xbound(-1.0, 1.0)\n ax2.set_ybound(0.0, 1.0)\n ax2.set_xlabel(r\"$x$\")\n ax2.set_ylabel(r\"$t$\")\n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_rarefaction_physical_characteristics, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.0), \n hm = FloatSlider(min = 0.1, max = 10.0, value = 0.5))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nWe clearly see that only if $h_m < h_l$ do the characteristics spread as they should for a rarefaction. This is, in fact, already given by results above: we showed that $\\partial_{\\xi} h \\propto -\\sqrt{h}$. As the height $h$ is positive, this means that as $\\xi$ increase across the rarefaction, the height must decrease.\n\n## All rarefaction solution\n\nThe above exercise assumed we knew the left state and found all right states connecting it by a rarefaction. Now we assume we know both left *and* right states, and assume they connect to a central state, *both* along rarefactions.\n\nFirst, we need to find which states will connect to the right state across a rarefaction.\n\n### Exercise\n\nRepeat the above calculations for states connecting to a known right state. That is, show that, given the right state $(h_r, u_r)$, the left state that connects to it across a rarefaction satisfies\n$$\n \\begin{pmatrix} h \\\\ u \\end{pmatrix} = \\begin{pmatrix} \\left( -\\frac{\\xi_r - \\xi}{3} + \\sqrt{h_r} \\right)^2 \\\\ \\frac{2}{3} (\\xi - \\xi_r) + u_r \\end{pmatrix}. \n$$\nor equivalently, given $h_m$, that\n$$\n u_m = u_r - 2 \\left( \\sqrt{h_r} - \\sqrt{h_m} \\right).\n$$\nAlso check that $h$ decreases across the rarefaction, so for a physical solution $h_m < h_r$.\n\nThen we can plot the curve of all states that can be connected to $(h_l, u_l)$ across a left rarefaction, and the curve of all states that can be connected to $(h_r, u_r)$ across a right rarefaction. *If* they intersect along the *physical* part of the curve, then we have the solution to the Riemann problem. Clearly this only occurs if $h_m < h_l$ *and* $h_m < h_r$.\n\nIn this case (and note that this is a special case!) we can solve it analytically. We note that, using our *assumption* that both curves are rarefactions, we have that\n$$\n\\begin{align}\n u_m & = u_l + 2 \\left( \\sqrt{h_l} - \\sqrt{h_m} \\right) \\\\\n & = u_r - 2 \\left( \\sqrt{h_r} - \\sqrt{h_m} \\right)\n\\end{align}\n$$\nTherefore we have\n$$\n h_m = \\frac{1}{16} \\left( u_l - u_r + 2 \\left( \\sqrt{h_l} + \\sqrt{h_r} \\right) \\right)^2.\n$$\n\n\n```python\ndef plot_sw_all_rarefaction(hl, ul, hr, ur):\n \"Plot the all rarefaction solution curve for states (hl, ul) and (hr, ur)\"\n \n hm = (ul - ur + 2.0 * (np.sqrt(hl) + np.sqrt(hr)))**2 / 16.0\n um = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hm))\n \n h_maximum = np.max([h_max, hl, hr, hm])\n h_minimum = np.min([h_min, hl, hr, hm])\n u_maximum = np.max([u_max, ul, ur, um])\n u_minimum = np.min([u_min, ul, ur, um])\n dh = h_maximum - h_minimum\n du = u_maximum - u_minimum\n xil_min = u_minimum - np.sqrt(h_maximum)\n xil_max = u_maximum - np.sqrt(h_minimum)\n xir_min = u_minimum + np.sqrt(h_minimum)\n xir_max = u_maximum + np.sqrt(h_maximum)\n \n xil = ul - np.sqrt(hl)\n xilm = um - np.sqrt(hm)\n xil_physical = np.linspace(xil, xil_max)\n xil_unphysical = np.linspace(xil_min, xil)\n hl_physical = ((xil - xil_physical) / 3.0 + np.sqrt(hl))**2\n ul_physical = 2.0 * (xil_physical - xil) / 3.0 + ul\n hl_unphysical = ((xil - xil_unphysical) / 3.0 + np.sqrt(hl))**2\n ul_unphysical = 2.0 * (xil_unphysical - xil) / 3.0 + ul\n \n xir = ur + np.sqrt(hr)\n xirm = um + np.sqrt(hm)\n xir_unphysical = np.linspace(xir, xir_max)\n xir_physical = np.linspace(xir_min, xir)\n hr_physical = (-(xir - xir_physical) / 3.0 + np.sqrt(hr))**2\n ur_physical = 2.0 * (xir_physical - xir) / 3.0 + ur\n hr_unphysical = (-(xir - xir_unphysical) / 3.0 + np.sqrt(hr))**2\n ur_unphysical = 2.0 * (xir_unphysical - xir) / 3.0 + ur\n \n fig = plt.figure(figsize=(12,8))\n ax1 = fig.add_subplot(111)\n if (hm < np.min([hl, hr])):\n ax1.plot(hm, um, 'b+', markersize = 16, markeredgewidth = 3, \n label=r\"$(h_m, u_m)$, physical solution\")\n else:\n ax1.plot(hm, um, 'b+', markersize = 16, markeredgewidth = 3, \n label=r\"$(h_m, u_m)$, not physical solution\")\n ax1.plot(hl, ul, 'rx', markersize = 16, markeredgewidth = 3, label=r\"$(h_l, u_l)$\")\n ax1.plot(hr, ur, 'go', markersize = 16, markeredgewidth = 3, label=r\"$(h_r, u_r)$\")\n ax1.plot(hl_physical, ul_physical, 'k-', linewidth = 2, label=\"Physical (left)\")\n ax1.plot(hl_unphysical, ul_unphysical, 'k--', linewidth = 2, label=\"Unphysical (left)\")\n ax1.plot(hr_physical, ur_physical, 'c-', linewidth = 2, label=\"Physical (right)\")\n ax1.plot(hr_unphysical, ur_unphysical, 'c--', linewidth = 2, label=\"Unphysical (right)\")\n ax1.set_xlabel(r\"$h$\")\n ax1.set_ylabel(r\"$u$\")\n ax1.set_xbound(h_minimum - 0.1 * dh, h_maximum + 0.1 * dh)\n ax1.set_ybound(u_minimum - 0.1 * du, u_maximum + 0.1 * du)\n ax1.legend()\n \n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_all_rarefaction, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = -0.5), \n hr = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ur = FloatSlider(min = -1.0, max = 1.0, value = 0.5))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nGiven the central state and the relation along rarefaction curves, we can then construct the characteristics and the solution in terms of the similarity coordinate (which, given a time $t$, gives the solution as a function of $x$).\n\n\n```python\ndef plot_sw_all_rarefaction_solution(hl, ul, hr, ur):\n \"Plot the all rarefaction solution curve for states (hl, ul) and (hr, ur)\"\n \n hm = (ul - ur + 2.0 * (np.sqrt(hl) + np.sqrt(hr)))**2 / 16.0\n um = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hm))\n \n xi1l = ul - np.sqrt(hl)\n xi1m = um - np.sqrt(hm)\n xi1r = ur - np.sqrt(hr)\n hl_raref = np.linspace(hl, hm, 20)\n ul_raref = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hl_raref))\n xil_raref = ul_raref - np.sqrt(hl_raref)\n \n xi2r = ur + np.sqrt(hr)\n xi2m = um + np.sqrt(hm)\n xi2l = ul + np.sqrt(hl)\n hr_raref = np.linspace(hm, hr)\n ur_raref = ur - 2.0 * (np.sqrt(hr) - np.sqrt(hr_raref))\n xir_raref = ur_raref + np.sqrt(hr_raref)\n \n xi_min = np.min([-1.0, xi1l, xi1m, xi2r, xi2m])\n xi_max = np.max([1.0, xi1l, xi1m, xi2r, xi2m])\n d_xi = xi_max - xi_min\n h_max = np.max([hl, hr, hm])\n h_min = np.min([hl, hr, hm])\n d_h = h_max - h_min\n u_max = np.max([ul, ur, um])\n u_min = np.min([ul, ur, um])\n d_u = u_max - u_min\n \n xi = np.array([xi_min - 0.1 * d_xi, xi1l])\n h = np.array([hl, hl])\n u = np.array([ul, ul])\n xi = np.append(xi, xil_raref)\n h = np.append(h, hl_raref)\n u = np.append(u, ul_raref)\n xi = np.append(xi, [xi1m, xi2m])\n h = np.append(h, [hm, hm])\n u = np.append(u, [um, um])\n xi = np.append(xi, xir_raref)\n h = np.append(h, hr_raref)\n u = np.append(u, ur_raref)\n xi = np.append(xi, [xi2r, xi_max + 0.1 * d_xi])\n h = np.append(h, [hr, hr])\n u = np.append(u, [ur, ur])\n \n fig = plt.figure(figsize=(12,8))\n ax1 = fig.add_subplot(221)\n if (hm < np.min([hl, hr])):\n ax1.plot(xi, h, 'b-', label = \"Physical solution\")\n else:\n ax1.plot(xi, h, 'r--', label = \"Unphysical solution\")\n ax1.set_ybound(h_min - 0.1 * d_h, h_max + 0.1 * d_h)\n ax1.set_xlabel(r\"$\\xi$\")\n ax1.set_ylabel(r\"$h$\")\n ax1.legend()\n ax2 = fig.add_subplot(222)\n if (hm < np.min([hl, hr])):\n ax2.plot(xi, u, 'b-', label = \"Physical solution\")\n else:\n ax2.plot(xi, u, 'r--', label = \"Unphysical solution\")\n ax2.set_ybound(u_min - 0.1 * d_u, u_max + 0.1 * d_u)\n ax2.set_xlabel(r\"$\\xi$\")\n ax2.set_ylabel(r\"$u$\")\n ax2.legend()\n \n ax3 = fig.add_subplot(223)\n left_end = np.min([-1.0, 1.1*xi1l])\n right_end = np.max([1.0, 1.1*xi2r])\n left_edge = left_end - xi1l\n right_edge = right_end - xi1r\n x1_start_points_l = np.linspace(np.min([left_edge, left_end]), 0.0, 20)\n x1_start_points_r = np.linspace(0.0, np.max([right_edge, right_end]), 20)\n x1_end_points_l = x1_start_points_l + xi1l\n t1_end_points_r = np.ones_like(x1_start_points_r)\n \n # Look for intersections\n t1_end_points_r = np.minimum(t1_end_points_r, x1_start_points_r / (xi2r - xi1r))\n x1_end_points_r = x1_start_points_r + xi1r * t1_end_points_r\n # Note: here we are cheating, and using the characteristic speed of the middle state, \n # ignoring howo it varies across the rarefaction\n x1_final_points_r = x1_end_points_r + (1.0 - t1_end_points_r) * xi1m\n \n for xs, xe in zip(x1_start_points_l, x1_end_points_l):\n ax3.plot([xs, xe], [0.0, 1.0], 'b-')\n for xs, xe, te in zip(x1_start_points_r, x1_end_points_r, t1_end_points_r):\n ax3.plot([xs, xe], [0.0, te], 'g-')\n for xs, xe, ts in zip(x1_end_points_r, x1_final_points_r, t1_end_points_r):\n ax3.plot([xs, xe], [ts, 1.0], 'g-')\n \n # Highlight the edges of both rarefactions\n ax3.plot([0.0, xi1l], [0.0, 1.0], 'r-', linewidth=2)\n ax3.plot([0.0, xi1m], [0.0, 1.0], 'r-', linewidth=2)\n ax3.plot([0.0, xi2m], [0.0, 1.0], 'r-', linewidth=2)\n ax3.plot([0.0, xi2r], [0.0, 1.0], 'r-', linewidth=2)\n \n # Rarefaction wave\n if (xi1l < xi1m):\n xi = np.linspace(xi1l, xi1m, 11)\n x_end_rarefaction = xi\n for xe in x_end_rarefaction:\n ax3.plot([0.0, xe], [0.0, 1.0], 'r--')\n else:\n x_fill = [xi1l, 0.0, xi1m]\n t_fill = [1.0, 0.0, 1.0]\n ax3.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n ax3.set_xlabel(r\"$x$\")\n ax3.set_ylabel(r\"$t$\")\n ax3.set_title(\"1-characteristics\")\n ax3.set_xbound(left_end, right_end)\n \n ax4 = fig.add_subplot(224)\n left_end = np.min([-1.0, 1.1*xi1l])\n right_end = np.max([1.0, 1.1*xi2r])\n left_edge = left_end - xi2l\n right_edge = right_end - xi2r\n x2_start_points_l = np.linspace(np.min([left_edge, left_end]), 0.0, 20)\n x2_start_points_r = np.linspace(0.0, np.max([right_edge, right_end]), 20)\n x2_end_points_r = x2_start_points_r + xi2r\n t2_end_points_l = np.ones_like(x2_start_points_l)\n \n # Look for intersections\n t2_end_points_l = np.minimum(t2_end_points_l, x2_start_points_l / (xi1l - xi2r))\n x2_end_points_l = x2_start_points_l + xi2r * t2_end_points_l\n # Note: here we are cheating, and using the characteristic speed of the middle state, \n # ignoring howo it varies across the rarefaction\n x2_final_points_l = x2_end_points_l + (1.0 - t2_end_points_l) * xi2m\n \n for xs, xe in zip(x2_start_points_r, x2_end_points_r):\n ax4.plot([xs, xe], [0.0, 1.0], 'g-')\n for xs, xe, te in zip(x2_start_points_l, x2_end_points_l, t2_end_points_l):\n ax4.plot([xs, xe], [0.0, te], 'b-')\n for xs, xe, ts in zip(x2_end_points_l, x2_final_points_l, t2_end_points_l):\n ax4.plot([xs, xe], [ts, 1.0], 'b-')\n \n # Highlight the edges of both rarefactions\n ax4.plot([0.0, xi1l], [0.0, 1.0], 'r-', linewidth=2)\n ax4.plot([0.0, xi1m], [0.0, 1.0], 'r-', linewidth=2)\n ax4.plot([0.0, xi2m], [0.0, 1.0], 'r-', linewidth=2)\n ax4.plot([0.0, xi2r], [0.0, 1.0], 'r-', linewidth=2)\n \n # Rarefaction wave\n if (xi2r > xi2m):\n xi = np.linspace(xi2m, xi2r, 11)\n x_end_rarefaction = xi\n for xe in x_end_rarefaction:\n ax4.plot([0.0, xe], [0.0, 1.0], 'r--')\n else:\n x_fill = [xi2m, 0.0, xi2r]\n t_fill = [1.0, 0.0, 1.0]\n ax4.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n ax4.set_xlabel(r\"$x$\")\n ax4.set_ylabel(r\"$t$\")\n ax4.set_title(\"2-characteristics\")\n ax4.set_xbound(left_end, right_end)\n \n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_all_rarefaction_solution, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = -0.5), \n hr = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ur = FloatSlider(min = -1.0, max = 1.0, value = 0.5))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\n## Shocks\n\nWe note that the [general theory](Lesson_Theory.ipynb) tells us that across a shock the Rankine-Hugoniot conditions\n$$\n V_s \\left[ {\\bf q} \\right] = \\left[ {\\bf f}({\\bf q}) \\right]\n$$\nmust be satisfied.\n\nFor the shallow water equations we will start, as with the rarefaction case, by assuming we know the left state ${\\bf q}_l = (h_l, u_l)$, and work out which states ${\\bf q}_m$ can be connected to it across a shock. \n\nNote here that the procedure is *identical* for the right state as the direction does not matter. However, there will be multiple solutions, and checking which is physically correct does require checking whether the left or the right state is known\n\nWriting out the conditions in full we see that\n$$\n\\begin{align}\n V_s \\left( h_m - h_l \\right) & = h_m u_m - h_l u_l \\\\\n V_s \\left( h_m u_m - h_l u_l \\right) & = h_m u_m^2 + \\tfrac{1}{2} h_m^2 - h_l u_l^2 - \\tfrac{1}{2} h_l^2\n\\end{align}\n$$\n\nEliminating the shock speed $V_s$ gives, using the second equation,\n$$\n u_m^2 - (2 u_l) u_m + \\left[ u_l^2 - \\tfrac{1}{2} \\left( h_l - h_m \\right) \\left( \\frac{h_l}{h_m} - \\frac{h_m}{h_l} \\right) \\right] = 0.\n$$\nThis has the solutions (assuming that $h_m$ is known!)\n$$\n u_m = u_l \\pm \\sqrt{\\tfrac{1}{2} \\left( h_l - h_m \\right) \\left( \\frac{h_l}{h_m} - \\frac{h_m}{h_l} \\right)}.\n$$\n\nWe can again use the Rankine-Hugoniot relations to find the shock speed.\n$$\n V_s = u_l \\pm \\frac{h_m}{h_m - h_l} \\sqrt{\\tfrac{1}{2} \\left( h_l - h_m \\right) \\left( \\frac{h_l}{h_m} - \\frac{h_m}{h_l} \\right)}.\n$$\n\nWe should at this point find which sign is appropriate. Comparing the shock speeds against the characteristic speed will show that\n\n* we need $h_m > h_l$ for the wave to be a shock, and\n* we take the negative sign if connected to a left state, and the positive if connected to a right state.\n\nHowever, we can see this by plotting the *Hugoniot locus*: the curve of all states that can be connected to $(h_l, u_l)$ across a shock.\n\n\n```python\ndef plot_sw_shock_physical(hl, ul):\n \"Plot the shock curve through the state (hl, ul)\"\n \n h = np.linspace(h_min, h_max, 500)\n u_negative = ul - np.sqrt(0.5 * (hl - h) * (hl / h - h / hl))\n u_positive = ul + np.sqrt(0.5 * (hl - h) * (hl / h - h / hl))\n \n vs_negative = ul - h / (h - hl) * np.sqrt(0.5 * (hl - h) * (hl / h - h / hl))\n vs_positive = ul + h / (h - hl) * np.sqrt(0.5 * (hl - h) * (hl / h - h / hl))\n \n xi1_negative = u_negative - np.sqrt(h) \n xi1_positive = u_positive - np.sqrt(h)\n xi2_negative = u_negative + np.sqrt(h) \n xi2_positive = u_positive + np.sqrt(h)\n \n xi1_l = ul - np.sqrt(hl)\n xi2_l = ul + np.sqrt(hl)\n \n h1_physical = h[np.logical_and(xi1_negative <= vs_negative, xi1_l >= vs_negative)]\n u1_physical = u_negative[np.logical_and(xi1_negative <= vs_negative, xi1_l >= vs_negative)]\n h2_physical = h[np.logical_and(xi2_positive >= vs_positive, xi2_l <= vs_positive)]\n u2_physical = u_positive[np.logical_and(xi2_positive >= vs_positive, xi2_l <= vs_positive)]\n h1_unphysical = h[np.logical_or(xi1_negative >= vs_negative, xi1_l <= vs_negative)]\n u1_unphysical = u_negative[np.logical_or(xi1_negative >= vs_negative, xi1_l <= vs_negative)]\n h2_unphysical = h[np.logical_or(xi2_positive <= vs_positive, xi2_l >= vs_positive)]\n u2_unphysical = u_positive[np.logical_or(xi2_positive <= vs_positive, xi2_l >= vs_positive)]\n \n fig = plt.figure(figsize=(12,8))\n ax = fig.add_subplot(111)\n ax.plot(hl, ul, 'rx', markersize = 16, markeredgewidth = 3)\n ax.plot(h1_physical, u1_physical, 'b-', linewidth = 2, \n label=\"Physical, 1-shock\")\n ax.plot(h1_unphysical, u1_unphysical, 'b--', linewidth = 2, \n label=\"Unphysical, 1-shock\")\n ax.plot(h2_physical, u2_physical, 'g-', linewidth = 2, \n label=\"Physical, 2-shock\")\n ax.plot(h2_unphysical, u2_unphysical, 'g--', linewidth = 2, \n label=\"Unphysical, 2-shock\")\n ax.plot(h[::5], u_negative[::5], 'co', markersize = 12, markeredgewidth = 2, alpha = 0.3,\n label=\"Negative branch\")\n ax.plot(h[::5], u_positive[::5], 'ro', markersize = 12, markeredgewidth = 2, alpha = 0.3,\n label=\"Positive branch\")\n ax.set_xlabel(r\"$h$\")\n ax.set_ylabel(r\"$u$\")\n dh = h_max - h_min\n du = u_max - u_min\n ax.set_xbound(h_min, h_max)\n ax.set_ybound(u_min, u_max)\n ax.legend()\n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_shock_physical, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.0))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nWe see from these results, as claimed above, that\n\n* we need $h_m > h_l$ (or $h_m > h_r$) for the wave to be a shock, and\n* we take the negative sign if connected to a left state, and the positive if connected to a right state.\n\n## All shock solution\n\nWhen we assumed the solution contained two rarefactions it was possible to write the full solution in closed form. If we assume the solution contains two shocks then it is not possible to do this. However, it is straightforward to find the solution numerically. \n\nWe assume the left state ${\\bf w}_l = (h_l, u_l)$ and the right state ${\\bf w}_r = (h_r, u_r)$ are known, and that they both connect to the central state ${\\bf w}_m = (h_m, u_m)$ through shocks. We know that\n$$\n\\begin{align}\n u_m & = u_l - \\sqrt{\\tfrac{1}{2} \\left( h_l - h_m \\right) \\left( \\frac{h_l}{h_m} - \\frac{h_m}{h_l} \\right)}, \\\\\n u_m & = u_r + \\sqrt{\\tfrac{1}{2} \\left( h_r - h_m \\right) \\left( \\frac{h_r}{h_m} - \\frac{h_m}{h_r} \\right)}.\n\\end{align}\n$$\nWe schematically write these equations as\n$$\n\\begin{align}\n u_m & = \\phi_l \\left( h_m; {\\bf w}_l \\right), \\\\\n u_m & = \\phi_r \\left( h_m; {\\bf w}_r \\right),\n\\end{align}\n$$\nto indicate that the velocity in the central state, $u_m$, can be written as a function of the single unknown $h_m$ and known data.\n\nWe immediately see that $h_m$ is a root of the nonlinear equation\n$$\n \\phi \\left( h_m; {\\bf w}_l, {\\bf w}_r \\right) = \\phi_l \\left( h_m; {\\bf w}_l \\right) - \\phi_r \\left( h_m; {\\bf w}_r \\right) = 0.\n$$\n\nFinding the roots of scalar nonlinear equations is a standard problem in numerical methods, with methods such as bisection, Newton-Raphson and more being well-known. `scipy` provides a number of standard algorithms - here we will use the recommended `brentq` method.\n\nNote that as soon as we have numerically determined $h_m$ then either formula above gives $u_m$, and the shock speeds follow.\n\n\n```python\ndef plot_sw_all_shock(hl, ul, hr, ur):\n \"Plot the all shock solution curve for states (hl, ul) and (hr, ur)\"\n \n from scipy.optimize import brentq\n \n def phi(hstar):\n \"Function defining the root\"\n \n phi_l = ul - np.sqrt(0.5 * (hl - hstar) * (hl / hstar - hstar / hl))\n phi_r = ur + np.sqrt(0.5 * (hr - hstar) * (hr / hstar - hstar / hr))\n \n return phi_l - phi_r\n \n # There is a solution only in the physical case. \n physical_solution = True\n try:\n hm = brentq(phi, np.max([hl, hr]), 10.0 * h_max)\n except ValueError:\n physical_solution = False\n hm = hl\n um = ul - np.sqrt(0.5 * (hl - hm) * (hl / hm - hm / hl))\n \n h = np.linspace(h_min, h_max, 500)\n u_negative = ul - np.sqrt(0.5 * (hl - h) * (hl / h - h / hl))\n u_positive = ur + np.sqrt(0.5 * (hr - h) * (hr / h - h / hr))\n \n h_maximum = np.max([h_max, hl, hr, hm])\n h_minimum = np.min([h_min, hl, hr, hm])\n u_maximum = np.max([u_max, ul, ur, um])\n u_minimum = np.min([u_min, ul, ur, um])\n dh = h_maximum - h_minimum\n du = u_maximum - u_minimum\n xil_min = u_minimum - np.sqrt(h_maximum)\n xil_max = u_maximum - np.sqrt(h_minimum)\n xir_min = u_minimum + np.sqrt(h_minimum)\n xir_max = u_maximum + np.sqrt(h_maximum)\n \n vs_negative = ul - h / (h - hl) * np.sqrt(0.5 * (hl - h) * (hl / h - h / hl))\n vs_positive = ur + h / (h - hr) * np.sqrt(0.5 * (hr - h) * (hr / h - h / hr))\n \n xi1_negative = u_negative - np.sqrt(h) \n xi1_positive = u_positive - np.sqrt(h)\n xi2_negative = u_negative + np.sqrt(h) \n xi2_positive = u_positive + np.sqrt(h)\n \n xi1_l = ul - np.sqrt(hl)\n xi2_r = ur + np.sqrt(hr)\n \n h1_physical = h[np.logical_and(xi1_negative <= vs_negative, xi1_l >= vs_negative)]\n u1_physical = u_negative[np.logical_and(xi1_negative <= vs_negative, xi1_l >= vs_negative)]\n h2_physical = h[np.logical_and(xi2_positive >= vs_positive, xi2_r <= vs_positive)]\n u2_physical = u_positive[np.logical_and(xi2_positive >= vs_positive, xi2_r <= vs_positive)]\n h1_unphysical = h[np.logical_or(xi1_negative >= vs_negative, xi1_l <= vs_negative)]\n u1_unphysical = u_negative[np.logical_or(xi1_negative >= vs_negative, xi1_l <= vs_negative)]\n h2_unphysical = h[np.logical_or(xi2_positive <= vs_positive, xi2_r >= vs_positive)]\n u2_unphysical = u_positive[np.logical_or(xi2_positive <= vs_positive, xi2_r >= vs_positive)]\n \n fig = plt.figure(figsize=(12,8))\n ax = fig.add_subplot(111)\n ax.plot(hl, ul, 'rx', markersize = 16, markeredgewidth = 3, label = r\"${\\bf w}_l$\")\n ax.plot(hr, ur, 'r+', markersize = 16, markeredgewidth = 3, label = r\"${\\bf w}_r$\")\n if physical_solution:\n ax.plot(hm, um, 'ro', markersize = 16, markeredgewidth = 3, label = r\"${\\bf w}_m$\")\n ax.plot(h1_physical, u1_physical, 'b-', linewidth = 2, \n label=\"Physical, 1-shock\")\n ax.plot(h1_unphysical, u1_unphysical, 'b--', linewidth = 2, \n label=\"Unphysical, 1-shock\")\n ax.plot(h2_physical, u2_physical, 'g-', linewidth = 2, \n label=\"Physical, 2-shock\")\n ax.plot(h2_unphysical, u2_unphysical, 'g--', linewidth = 2, \n label=\"Unphysical, 2-shock\")\n ax.set_xlabel(r\"$h$\")\n ax.set_ylabel(r\"$u$\")\n ax.set_xbound(h_minimum - 0.1 * dh, h_maximum + 0.1 * dh)\n ax.set_ybound(u_minimum - 0.1 * du, u_maximum + 0.1 * du)\n ax.legend()\n \n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_all_shock, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.2), \n hr = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ur = FloatSlider(min = -1.0, max = 1.0, value = -0.2))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nFinally, we can plot the solution in physical space.\n\n\n```python\ndef plot_sw_all_shock_solution(hl, ul, hr, ur):\n \"Plot the all shock solution for states (hl, ul) and (hr, ur)\"\n \n from scipy.optimize import brentq\n \n def phi(hstar):\n \"Function defining the root\"\n \n phi_l = ul - np.sqrt(0.5 * (hl - hstar) * (hl / hstar - hstar / hl))\n phi_r = ur + np.sqrt(0.5 * (hr - hstar) * (hr / hstar - hstar / hr))\n \n return phi_l - phi_r\n \n # There is a solution only in the physical case. \n physical_solution = True\n try:\n hm = brentq(phi, np.max([hl, hr]), 10.0 * h_max)\n except ValueError:\n physical_solution = False\n hm = hl\n um = ul - np.sqrt(0.5 * (hl - hm) * (hl / hm - hm / hl))\n \n xi1l = ul - np.sqrt(hl)\n xi1m = um - np.sqrt(hm)\n xi1r = ur - np.sqrt(hr)\n if physical_solution:\n vsl = ul - hm / (hm - hl) * np.sqrt(0.5 * (hl - hm) * (hl / hm - hm / hl))\n else:\n vsl = xi1l\n \n xi2r = ur + np.sqrt(hr)\n xi2m = um + np.sqrt(hm)\n xi2l = ul + np.sqrt(hl)\n if physical_solution:\n vsr = ur + hm / (hm - hr) * np.sqrt(0.5 * (hr - hm) * (hr / hm - hm / hr))\n else:\n vsr = xi2r\n \n xi_min = np.min([-1.0, xi1l, xi1m, xi2r, xi2m])\n xi_max = np.max([1.0, xi1l, xi1m, xi2r, xi2m])\n d_xi = xi_max - xi_min\n h_maximum = np.max([hl, hr, hm])\n h_minimum = np.min([hl, hr, hm])\n d_h = h_maximum - h_minimum\n u_maximum = np.max([ul, ur, um])\n u_minimum = np.min([ul, ur, um])\n d_u = u_maximum - u_minimum\n \n xi = np.array([xi_min - 0.1 * d_xi, vsl, vsl, vsr, vsr, xi_max + 0.1 * d_xi])\n h = np.array([hl, hl, hm, hm, hr, hr])\n u = np.array([ul, ul, um, um, ur, ur])\n \n fig = plt.figure(figsize=(12,8))\n ax1 = fig.add_subplot(221)\n if (hm > np.max([hl, hr])):\n ax1.plot(xi, h, 'b-', label = \"Physical solution\")\n else:\n ax1.plot(xi, h, 'r--', label = \"Unphysical solution\")\n ax1.set_ybound(h_minimum - 0.1 * d_h, h_maximum + 0.1 * d_h)\n ax1.set_xlabel(r\"$\\xi$\")\n ax1.set_ylabel(r\"$h$\")\n ax1.legend()\n ax2 = fig.add_subplot(222)\n if (hm > np.max([hl, hr])):\n ax2.plot(xi, u, 'b-', label = \"Physical solution\")\n else:\n ax2.plot(xi, u, 'r--', label = \"Unphysical solution\")\n ax2.set_ybound(u_minimum - 0.1 * d_u, u_maximum + 0.1 * d_u)\n ax2.set_xlabel(r\"$\\xi$\")\n ax2.set_ylabel(r\"$u$\")\n ax2.legend()\n \n ax3 = fig.add_subplot(223)\n left_end = np.min([-1.0, 1.1*xi1l])\n right_end = np.max([1.0, 1.1*xi2r])\n left_edge = left_end - xi1l\n right_edge = right_end - xi1r\n x1_start_points_l = np.linspace(np.min([left_edge, left_end]), 0.0, 20)\n x1_start_points_r = np.linspace(0.0, np.max([right_edge, right_end]), 20)\n t1_end_points_l = np.ones_like(x1_start_points_l)\n t1_end_points_r = np.ones_like(x1_start_points_r)\n \n # Look for intersections\n t1_end_points_l = np.minimum(t1_end_points_l, x1_start_points_l / (vsl - xi1l))\n x1_end_points_l = x1_start_points_l + xi1l * t1_end_points_l\n t1_end_points_r = np.minimum(t1_end_points_r, x1_start_points_r / (vsr - xi1r))\n x1_end_points_r = x1_start_points_r + xi1r * t1_end_points_r\n # Note: here we are cheating, and using the characteristic speed of the middle state, \n # ignoring how it varies across the rarefaction\n t1_final_points_r = np.ones_like(x1_start_points_r)\n t1_final_points_r = np.minimum(t1_final_points_r, \n (x1_end_points_r - t1_end_points_r * xi1m) / (vsl - xi1m))\n x1_final_points_r = x1_end_points_r + (t1_final_points_r - t1_end_points_r) * xi1m\n \n for xs, xe, te in zip(x1_start_points_l, x1_end_points_l, t1_end_points_l):\n ax3.plot([xs, xe], [0.0, te], 'b-')\n for xs, xe, te in zip(x1_start_points_r, x1_end_points_r, t1_end_points_r):\n ax3.plot([xs, xe], [0.0, te], 'g-')\n for xs, xe, ts, te in zip(x1_end_points_r, x1_final_points_r, t1_end_points_r, \n t1_final_points_r):\n ax3.plot([xs, xe], [ts, te], 'g-')\n \n # Highlight the shocks\n ax3.plot([0.0, vsl], [0.0, 1.0], 'r-', linewidth=2)\n ax3.plot([0.0, vsr], [0.0, 1.0], 'r-', linewidth=2)\n \n # Unphysical shock\n if not physical_solution:\n x_fill = []\n if xi1l < xi1m:\n x_fill = [xi1l, 0.0, xi1m]\n elif xi1l < vsl:\n x_fill = [xi1l, 0.0, vsl]\n elif vsl < xi1m:\n x_fill = [vsl, 0.0, xi1m]\n if len(x_fill) > 0:\n t_fill = [1.0, 0.0, 1.0]\n ax3.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n x_fill = []\n if xi2r > xi2m:\n x_fill = [xi2m, 0.0, xi2r]\n elif xi2m < vsr:\n x_fill = [xi2m, 0.0, vsr]\n elif vsr < xi2r:\n x_fill = [vsr, 0.0, xi2r]\n if len(x_fill) > 0:\n t_fill = [1.0, 0.0, 1.0]\n ax3.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n ax3.set_xlabel(r\"$x$\")\n ax3.set_ylabel(r\"$t$\")\n ax3.set_title(\"1-characteristics\")\n ax3.set_xbound(left_end, right_end)\n \n ax4 = fig.add_subplot(224)\n left_end = np.min([-1.0, 1.1*xi1l])\n right_end = np.max([1.0, 1.1*xi2r])\n left_edge = left_end - xi2l\n right_edge = right_end - xi2r\n x2_start_points_l = np.linspace(np.min([left_edge, left_end]), 0.0, 20)\n x2_start_points_r = np.linspace(0.0, np.max([right_edge, right_end]), 20)\n x2_end_points_r = x2_start_points_r + xi2r\n t2_end_points_l = np.ones_like(x2_start_points_l)\n t2_end_points_r = np.ones_like(x2_start_points_r)\n \n # Look for intersections\n t2_end_points_r = np.minimum(t2_end_points_r, x2_start_points_r / (vsr - xi2r))\n x2_end_points_r = x2_start_points_r + xi2r * t2_end_points_r\n t2_end_points_l = np.minimum(t2_end_points_l, x2_start_points_l / (vsl - xi2l))\n x2_end_points_l = x2_start_points_l + xi2l * t2_end_points_l\n # Note: here we are cheating, and using the characteristic speed of the middle state, \n # ignoring how it varies across the rarefaction\n t2_final_points_l = np.ones_like(x2_start_points_l)\n t2_final_points_l = np.minimum(t2_final_points_l, \n (x2_end_points_l - t2_end_points_l * xi2m) / (vsr - xi2m))\n x2_final_points_l = x2_end_points_l + (t2_final_points_l - t2_end_points_l) * xi2m\n \n for xs, xe, te in zip(x2_start_points_r, x2_end_points_r, t2_end_points_r):\n ax4.plot([xs, xe], [0.0, te], 'b-')\n for xs, xe, te in zip(x2_start_points_l, x2_end_points_l, t2_end_points_l):\n ax4.plot([xs, xe], [0.0, te], 'g-')\n for xs, xe, ts, te in zip(x2_end_points_l, x2_final_points_l, t2_end_points_l, \n t2_final_points_l):\n ax4.plot([xs, xe], [ts, te], 'g-')\n \n # Highlight the shocks\n ax4.plot([0.0, vsl], [0.0, 1.0], 'r-', linewidth=2)\n ax4.plot([0.0, vsr], [0.0, 1.0], 'r-', linewidth=2)\n \n # Unphysical shock\n if not physical_solution:\n x_fill = []\n if xi1l < xi1m:\n x_fill = [xi1l, 0.0, xi1m]\n elif xi1l < vsl:\n x_fill = [xi1l, 0.0, vsl]\n elif vsl < xi1m:\n x_fill = [vsl, 0.0, xi1m]\n if len(x_fill) > 0:\n t_fill = [1.0, 0.0, 1.0]\n ax4.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n x_fill = []\n if xi2r > xi2m:\n x_fill = [xi2m, 0.0, xi2r]\n elif xi2m < vsr:\n x_fill = [xi2m, 0.0, vsr]\n elif vsr < xi2r:\n x_fill = [vsr, 0.0, xi2r]\n if len(x_fill) > 0:\n t_fill = [1.0, 0.0, 1.0]\n ax4.fill_between(x_fill, t_fill, 1.0, facecolor = 'red', alpha = 0.5)\n \n ax4.set_xlabel(r\"$x$\")\n ax4.set_ylabel(r\"$t$\")\n ax4.set_title(\"2-characteristics\")\n ax4.set_xbound(left_end, right_end)\n \n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_all_shock_solution, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.2), \n hr = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ur = FloatSlider(min = -1.0, max = 1.0, value = -0.2))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\n## Full solution\n\nThe all shock solution illustrates how the full solution can be obtained. We know that \n\n1. the central state ${\\bf w}_m$ will be connected to the known states ${\\bf w}_{l, r}$ across waves that are either shocks or rarefactions,\n2. if $h_m > h_{l, r}$ then the wave will be a shock, otherwise it will be a rarefaction, and\n3. given $h_m$ and the known data, we can compute $u_m$ for either a shock or a rarefaction.\n\nSo, using the results above, we can find the full solution to the Riemann problem by solving the nonlinear algebraic root-finding problem\n$$\n \\Phi \\left( h_m ; {\\bf w}_l, {\\bf w}_r \\right) = 0,\n$$\nwhere\n$$\n \\Phi \\left( h_m ; {\\bf w}_l, {\\bf w}_r \\right) = \\Phi_l \\left( h_m ; {\\bf w}_l \\right) - \\Phi_r \\left( h_m ; {\\bf w}_r \\right),\n$$\nand\n$$\n\\begin{align}\n \\Phi_l & = u_m \\left( h_m ; {\\bf w}_l \\right) & \\Phi_r & = u_m \\left( h_m ; {\\bf w}_r \\right) \\\\\n & = \\begin{cases} u_l + 2 \\left( \\sqrt{h_l} - \\sqrt{h_m} \\right) & h_l > h_m \\\\ u_l - \\sqrt{\\tfrac{1}{2} \\left( h_l - h_m \\right) \\left( \\frac{h_l}{h_m} - \\frac{h_m}{h_l} \\right)} & h_l < h_m \\end{cases} & & = \\begin{cases} u_r - 2 \\left( \\sqrt{h_r} - \\sqrt{h_m} \\right) & h_r > h_m \\\\ u_r + \\sqrt{\\tfrac{1}{2} \\left( h_r - h_m \\right) \\left( \\frac{h_r}{h_m} - \\frac{h_m}{h_r} \\right)} & h_r < h_m \\end{cases}.\n\\end{align}\n$$\n\n\n```python\ndef plot_sw_Riemann_curves(hl, ul, hr, ur):\n \"Plot the solution curves for states (hl, ul) and (hr, ur)\"\n \n from scipy.optimize import brentq\n \n def phi(hstar):\n \"Function defining the root\"\n \n if hl < hstar:\n phi_l = ul - np.sqrt(0.5 * (hl - hstar) * (hl / hstar - hstar / hl))\n else:\n phi_l = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hstar))\n if hr < hstar:\n phi_r = ur + np.sqrt(0.5 * (hr - hstar) * (hr / hstar - hstar / hr))\n else:\n phi_r = ur - 2.0 * (np.sqrt(hr) - np.sqrt(hstar))\n \n return phi_l - phi_r\n \n hm = brentq(phi, 0.1 * h_min, 10.0 * h_max)\n if hl < hm:\n um = ul - np.sqrt(0.5 * (hl - hm) * (hl / hm - hm / hl))\n else:\n um = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hm))\n \n h_maximum = np.max([h_max, hl, hr, hm])\n h_minimum = np.min([h_min, hl, hr, hm])\n u_maximum = np.max([u_max, ul, ur, um])\n u_minimum = np.min([u_min, ul, ur, um])\n dh = h_maximum - h_minimum\n du = u_maximum - u_minimum\n \n # Now plot the rarefaction and shock curves as appropriate\n # Here we only plot the physical pieces.\n \n h1_shock = np.linspace(hl, h_max)\n u1_shock = ul - np.sqrt(0.5 * (hl - h1_shock) * (hl / h1_shock - h1_shock / hl))\n h2_shock = np.linspace(hr, h_max)\n u2_shock = ur + np.sqrt(0.5 * (hr - h2_shock) * (hr / h2_shock - h2_shock / hr))\n \n h1_rarefaction = np.linspace(h_min, hl)\n u1_rarefaction = ul + 2.0 * (np.sqrt(hl) - np.sqrt(h1_rarefaction))\n h2_rarefaction = np.linspace(h_min, hr)\n u2_rarefaction = ur - 2.0 * (np.sqrt(hr) - np.sqrt(h2_rarefaction))\n \n fig = plt.figure(figsize=(12,8))\n ax = fig.add_subplot(111)\n ax.plot(hl, ul, 'rx', markersize = 16, markeredgewidth = 3, label = r\"${\\bf w}_l$\")\n ax.plot(hr, ur, 'r+', markersize = 16, markeredgewidth = 3, label = r\"${\\bf w}_r$\")\n ax.plot(hm, um, 'ro', markersize = 16, markeredgewidth = 3, label = r\"${\\bf w}_m$\")\n ax.plot(h1_shock, u1_shock, 'b-', linewidth = 2, \n label=\"1-shock\")\n ax.plot(h1_rarefaction, u1_rarefaction, 'b-.', linewidth = 2, \n label=\"1-rarefaction\")\n ax.plot(h2_shock, u2_shock, 'g-', linewidth = 2, \n label=\"2-shock\")\n ax.plot(h2_rarefaction, u2_rarefaction, 'g-.', linewidth = 2, \n label=\"2-rarefaction\")\n ax.set_xlabel(r\"$h$\")\n ax.set_ylabel(r\"$u$\")\n ax.set_xbound(h_minimum - 0.1 * dh, h_maximum + 0.1 * dh)\n ax.set_ybound(u_minimum - 0.1 * du, u_maximum + 0.1 * du)\n ax.legend()\n \n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_Riemann_curves, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.2), \n hr = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ur = FloatSlider(min = -1.0, max = 1.0, value = -0.2))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n\nFinally, we can plot the solution in physical space.\n\n\n```python\ndef plot_sw_Riemann_solution(hl, ul, hr, ur):\n \"Plot the Riemann problem solution for states (hl, ul) and (hr, ur)\"\n \n from scipy.optimize import brentq\n \n def phi(hstar):\n \"Function defining the root\"\n \n if hl < hstar:\n phi_l = ul - np.sqrt(0.5 * (hl - hstar) * (hl / hstar - hstar / hl))\n else:\n phi_l = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hstar))\n if hr < hstar:\n phi_r = ur + np.sqrt(0.5 * (hr - hstar) * (hr / hstar - hstar / hr))\n else:\n phi_r = ur - 2.0 * (np.sqrt(hr) - np.sqrt(hstar))\n \n return phi_l - phi_r\n \n left_raref = False\n left_shock = False\n right_raref = False\n right_shock = False\n \n hm = brentq(phi, 0.1 * h_min, 10.0 * h_max)\n if hl < hm:\n um = ul - np.sqrt(0.5 * (hl - hm) * (hl / hm - hm / hl))\n else:\n um = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hm))\n \n h_maximum = np.max([h_max, hl, hr, hm])\n h_minimum = np.min([h_min, hl, hr, hm])\n u_maximum = np.max([u_max, ul, ur, um])\n u_minimum = np.min([u_min, ul, ur, um])\n dh = h_maximum - h_minimum\n du = u_maximum - u_minimum\n \n xi1l = ul - np.sqrt(hl)\n xi1m = um - np.sqrt(hm)\n xi1r = ur - np.sqrt(hr)\n if hm > hl:\n left_shock = True\n vsl = ul - hm / (hm - hl) * np.sqrt(0.5 * (hl - hm) * (hl / hm - hm / hl))\n else:\n left_raref = True\n hl_raref = np.linspace(hl, hm, 20)\n ul_raref = ul + 2.0 * (np.sqrt(hl) - np.sqrt(hl_raref))\n xil_raref = ul_raref - np.sqrt(hl_raref)\n \n xi2r = ur + np.sqrt(hr)\n xi2m = um + np.sqrt(hm)\n xi2l = ul + np.sqrt(hl)\n if hm > hr:\n right_shock = True\n vsr = ur + hm / (hm - hr) * np.sqrt(0.5 * (hr - hm) * (hr / hm - hm / hr))\n else:\n right_raref = True\n hr_raref = np.linspace(hm, hr)\n ur_raref = ur - 2.0 * (np.sqrt(hr) - np.sqrt(hr_raref))\n xir_raref = ur_raref + np.sqrt(hr_raref)\n \n xi_min = np.min([-1.0, xi1l, xi1m, xi2r, xi2m])\n xi_max = np.max([1.0, xi1l, xi1m, xi2r, xi2m])\n d_xi = xi_max - xi_min\n h_maximum = np.max([hl, hr, hm])\n h_minimum = np.min([hl, hr, hm])\n d_h = h_maximum - h_minimum\n u_maximum = np.max([ul, ur, um])\n u_minimum = np.min([ul, ur, um])\n d_u = u_maximum - u_minimum\n \n xi = np.array([xi_min - 0.1 * d_xi])\n h = np.array([hl])\n u = np.array([ul])\n if left_shock:\n xi = np.append(xi, [vsl, vsl])\n h = np.append(h, [hl, hm])\n u = np.append(u, [ul, um])\n else:\n xi = np.append(xi, xil_raref)\n h = np.append(h, hl_raref)\n u = np.append(u, ul_raref)\n if right_shock:\n xi = np.append(xi, [vsr, vsr])\n h = np.append(h, [hm, hr])\n u = np.append(u, [um, ur])\n else:\n xi = np.append(xi, xir_raref)\n h = np.append(h, hr_raref)\n u = np.append(u, ur_raref)\n xi = np.append(xi, [xi_max + 0.1 * d_xi])\n h = np.append(h, [hr])\n u = np.append(u, [ur])\n \n fig = plt.figure(figsize=(12,8))\n ax1 = fig.add_subplot(221)\n ax1.plot(xi, h, 'b-', label = \"True solution\")\n ax1.set_ybound(h_minimum - 0.1 * d_h, h_maximum + 0.1 * d_h)\n ax1.set_xlabel(r\"$\\xi$\")\n ax1.set_ylabel(r\"$h$\")\n ax1.legend()\n ax2 = fig.add_subplot(222)\n ax2.plot(xi, u, 'b-', label = \"True solution\")\n ax2.set_ybound(u_minimum - 0.1 * d_u, u_maximum + 0.1 * d_u)\n ax2.set_xlabel(r\"$\\xi$\")\n ax2.set_ylabel(r\"$u$\")\n ax2.legend()\n \n ax3 = fig.add_subplot(223)\n left_end = np.min([-1.0, 1.1*xi1l])\n right_end = np.max([1.0, 1.1*xi2r])\n left_edge = left_end - xi1l\n right_edge = right_end - xi1r\n x1_start_points_l = np.linspace(np.min([left_edge, left_end]), 0.0, 20)\n x1_start_points_r = np.linspace(0.0, np.max([right_edge, right_end]), 20)\n t1_end_points_l = np.ones_like(x1_start_points_l)\n t1_end_points_r = np.ones_like(x1_start_points_r)\n \n # Look for intersections\n if left_shock:\n t1_end_points_l = np.minimum(t1_end_points_l, x1_start_points_l / (vsl - xi1l))\n x1_end_points_l = x1_start_points_l + xi1l * t1_end_points_l\n if right_shock:\n t1_end_points_r = np.minimum(t1_end_points_r, x1_start_points_r / (vsr - xi1r))\n else:\n t1_end_points_r = np.minimum(t1_end_points_r, x1_start_points_r / (xi2r - xi1r))\n x1_end_points_r = x1_start_points_r + xi1r * t1_end_points_r\n # Note: here we are cheating, and using the characteristic speed of the middle state, \n # ignoring how it varies across the rarefaction\n t1_final_points_r = np.ones_like(x1_start_points_r)\n if left_shock:\n t1_final_points_r = np.minimum(t1_final_points_r, \n (x1_end_points_r - t1_end_points_r * xi1m) / \n (vsl - xi1m))\n x1_final_points_r = x1_end_points_r + (t1_final_points_r - t1_end_points_r) * xi1m\n \n for xs, xe, te in zip(x1_start_points_l, x1_end_points_l, t1_end_points_l):\n ax3.plot([xs, xe], [0.0, te], 'b-')\n for xs, xe, te in zip(x1_start_points_r, x1_end_points_r, t1_end_points_r):\n ax3.plot([xs, xe], [0.0, te], 'g-')\n for xs, xe, ts, te in zip(x1_end_points_r, x1_final_points_r, t1_end_points_r, \n t1_final_points_r):\n ax3.plot([xs, xe], [ts, te], 'g-')\n \n # Highlight the waves\n if left_shock:\n ax3.plot([0.0, vsl], [0.0, 1.0], 'r-', linewidth=2)\n else:\n ax3.plot([0.0, xi1l], [0.0, 1.0], 'r-', linewidth=2)\n ax3.plot([0.0, xi1m], [0.0, 1.0], 'r-', linewidth=2)\n xi = np.linspace(xi1l, xi1m, 11)\n x_end_rarefaction = xi\n for xe in x_end_rarefaction:\n ax3.plot([0.0, xe], [0.0, 1.0], 'r--')\n if right_shock:\n ax3.plot([0.0, vsr], [0.0, 1.0], 'r-', linewidth=2)\n else:\n ax3.plot([0.0, xi2m], [0.0, 1.0], 'r-', linewidth=2)\n ax3.plot([0.0, xi2r], [0.0, 1.0], 'r-', linewidth=2)\n \n ax3.set_xlabel(r\"$x$\")\n ax3.set_ylabel(r\"$t$\")\n ax3.set_title(\"1-characteristics\")\n ax3.set_xbound(left_end, right_end)\n \n ax4 = fig.add_subplot(224)\n left_end = np.min([-1.0, 1.1*xi1l])\n right_end = np.max([1.0, 1.1*xi2r])\n left_edge = left_end - xi2l\n right_edge = right_end - xi2r\n x2_start_points_l = np.linspace(np.min([left_edge, left_end]), 0.0, 20)\n x2_start_points_r = np.linspace(0.0, np.max([right_edge, right_end]), 20)\n x2_end_points_r = x2_start_points_r + xi2r\n t2_end_points_l = np.ones_like(x2_start_points_l)\n t2_end_points_r = np.ones_like(x2_start_points_r)\n \n # Look for intersections\n if right_shock:\n t2_end_points_r = np.minimum(t2_end_points_r, x2_start_points_r / (vsr - xi2r))\n x2_end_points_r = x2_start_points_r + xi2r * t2_end_points_r\n if left_shock:\n t2_end_points_l = np.minimum(t2_end_points_l, x2_start_points_l / (vsl - xi2l))\n else:\n t2_end_points_l = np.minimum(t2_end_points_l, x2_start_points_l / (xi1l - xi2l))\n x2_end_points_l = x2_start_points_l + xi2l * t2_end_points_l\n # Note: here we are cheating, and using the characteristic speed of the middle state, \n # ignoring how it varies across the rarefaction\n t2_final_points_l = np.ones_like(x2_start_points_l)\n if right_shock:\n t2_final_points_l = np.minimum(t2_final_points_l, \n (x2_end_points_l - t2_end_points_l * xi2m) / \n (vsr - xi2m))\n x2_final_points_l = x2_end_points_l + (t2_final_points_l - t2_end_points_l) * xi2m\n \n for xs, xe, te in zip(x2_start_points_r, x2_end_points_r, t2_end_points_r):\n ax4.plot([xs, xe], [0.0, te], 'b-')\n for xs, xe, te in zip(x2_start_points_l, x2_end_points_l, t2_end_points_l):\n ax4.plot([xs, xe], [0.0, te], 'g-')\n for xs, xe, ts, te in zip(x2_end_points_l, x2_final_points_l, t2_end_points_l, \n t2_final_points_l):\n ax4.plot([xs, xe], [ts, te], 'g-')\n \n # Highlight the waves\n if left_shock:\n ax4.plot([0.0, vsl], [0.0, 1.0], 'r-', linewidth=2)\n else:\n ax4.plot([0.0, xi1l], [0.0, 1.0], 'r-', linewidth=2)\n ax4.plot([0.0, xi1m], [0.0, 1.0], 'r-', linewidth=2)\n if right_shock:\n ax4.plot([0.0, vsr], [0.0, 1.0], 'r-', linewidth=2)\n else:\n ax4.plot([0.0, xi2m], [0.0, 1.0], 'r-', linewidth=2)\n ax4.plot([0.0, xi2r], [0.0, 1.0], 'r-', linewidth=2)\n xi = np.linspace(xi2m, xi2r, 11)\n x_end_rarefaction = xi\n for xe in x_end_rarefaction:\n ax4.plot([0.0, xe], [0.0, 1.0], 'r--')\n \n ax4.set_xlabel(r\"$x$\")\n ax4.set_ylabel(r\"$t$\")\n ax4.set_title(\"2-characteristics\")\n ax4.set_xbound(left_end, right_end)\n \n fig.tight_layout()\n```\n\n\n```python\ninteractive(plot_sw_Riemann_solution, \n hl = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ul = FloatSlider(min = -1.0, max = 1.0, value = 0.2), \n hr = FloatSlider(min = 0.1, max = 10.0, value = 1.0), \n ur = FloatSlider(min = -1.0, max = 1.0, value = -0.2))\n```\n\n\nFailed to display Jupyter Widget of type interactive.
\n If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n that the widgets JavaScript is still loading. If this message persists, it\n likely means that the widgets JavaScript library is either not installed or\n not enabled. See the Jupyter\n Widgets Documentation for setup instructions.\n
\n\n If you're reading this message in another frontend (for example, a static\n rendering on GitHub or NBViewer),\n it may mean that your frontend doesn't currently support widgets.\n
\n\n\n", "meta": {"hexsha": "c330800252791e09635d45654e049cbbe6d7f06a", "size": 93906, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Lesson_04_Shallow_Water.ipynb", "max_stars_repo_name": "IanHawke/RiemannPython", "max_stars_repo_head_hexsha": "57d6e372861a9c89b15755fb1d6ff9ea8116f6e2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 9, "max_stars_repo_stars_event_min_datetime": "2015-08-24T01:24:34.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-08T18:26:24.000Z", "max_issues_repo_path": "Lesson_04_Shallow_Water.ipynb", "max_issues_repo_name": "IanHawke/RiemannPython", "max_issues_repo_head_hexsha": "57d6e372861a9c89b15755fb1d6ff9ea8116f6e2", "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": "Lesson_04_Shallow_Water.ipynb", "max_forks_repo_name": "IanHawke/RiemannPython", "max_forks_repo_head_hexsha": "57d6e372861a9c89b15755fb1d6ff9ea8116f6e2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2018-07-31T17:41:21.000Z", "max_forks_repo_forks_event_max_datetime": "2019-07-11T13:50:22.000Z", "avg_line_length": 44.0459662289, "max_line_length": 510, "alphanum_fraction": 0.5244073861, "converted": true, "num_tokens": 21853, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.399811640739795, "lm_q2_score": 0.22000710486009023, "lm_q1q2_score": 0.0879614015685248}} {"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## Krmiljenje povratne zveze stanj - zmogljivost krmiljenja\n\nZa sistem:\n\n$$\n\\dot{x}=\\underbrace{\\begin{bmatrix}-0.5&1\\\\0&-0.1\\end{bmatrix}}_{A}x+\\underbrace{\\begin{bmatrix}0\\\\1\\end{bmatrix}}_{B}u\n$$\n\nnačrtuj krmilnik tako, da bo prva spremenljivka stanja sistema sledila referenčni koračni funkciji brez odstopka v stacionarnem času s časom ustalitve (odziv naj doseže 95% končne vrednosti) krajšim od 1 s.\n\nZ namenom zagotovitve zgornjim zahtevam dodamo fiktivno spremenljivko stanja $x_3$ z dinamiko $\\dot{x_3}=x_1-x_{1r}$, kjer $x_{1r}$ predstavlja referenčni signal, tako da, če je razširjen sistem asimptotično stabilen, potem konvergira nova spremenljivka stanja $x_3$ k vrednosti 0, kar zagotavlja, da gre $x_1$ k vrednosti $x_{1r}$.\n\nRazširjen sistem lahko popišemo z naslednjimi enačbami:\n\n$$\n\\dot{x}_a=\\underbrace{\\begin{bmatrix}-0.5&1&0\\\\0&-0.1&0\\\\1&0&0\\end{bmatrix}}_{A_a}x_a+\\underbrace{\\begin{bmatrix}0\\\\1\\\\0\\end{bmatrix}}_{B_a}u+\\underbrace{\\begin{bmatrix}0\\\\0\\\\-1\\end{bmatrix}}_{B_{\\text{ref}}}x_{1r}\n$$\n\nin naslednjo spoznavnostno matriko:\n\n$$\n\\begin{bmatrix}B_a&A_aB_a&A_a^2B_a\\end{bmatrix} = \\begin{bmatrix}0&1&-0.6\\\\1&-0.1&0.01\\\\0&0&1\\end{bmatrix}\n$$\n\nKer $\\text{rank}=3$ je razširjen sistem vodljiv.\n\nZ namenom zagotovitve druge zahteve, je možna rešitev ta, da s prilagajanjem polov dosežemo, da ima sistem dominanten pol pri $-3$ rad/s (opomba: $e^{\\lambda t}=e^{-3t}$ pri $t=1$ s znaša $0.4978..<0.05$). Izbrana pola sta tako $\\lambda_1=-3\\,\\text{in}\\,\\lambda_2=\\lambda_3=-30$, s pripadajočo matriko ojačanja $K_a=\\begin{bmatrix}1048.75&62.4&2700\\end{bmatrix}$.\n\nZaprtozančni sistem lahko tako zapišemo kot:\n\n$$\n\\dot{x}_a=(A_a-B_aK_a)x_a+B_av+B_{\\text{ref}}x_{1r}=\\begin{bmatrix}-0.5&1&0\\\\-1048.75&-62.5&-2700\\\\1&0&0\\end{bmatrix}x_a+\\begin{bmatrix}0\\\\1\\\\0\\end{bmatrix}v+\\begin{bmatrix}0\\\\0\\\\-1\\end{bmatrix}x_{1r}\n$$\n\n### Kako upravljati s tem interaktivnim primerom?\nPreizkusi različne rešitve s spreminjanjem ojačanja $K$ ali neposrednim določanjem vrednosti zaprtozančnih lastnih vrednosti.\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('-0.5 1 0; 0 -0.1 0; 1 0 0')\nB = numpy.matrix('0; 1; 0')\nBr = numpy.matrix('0; 0; -1')\nC = numpy.matrix('1 0 0')\nX0 = numpy.matrix('0; 0; 0')\nK = numpy.matrix([1048.75,62.4,2700])\n\nAw = matrixWidget(3,3)\nAw.setM(A)\nBw = matrixWidget(3,1)\nBw.setM(B)\nBrw = matrixWidget(3,1)\nBrw.setM(Br)\nCw = matrixWidget(1,3)\nCw.setM(C)\nX0w = matrixWidget(3,1)\nX0w.setM(X0)\nKw = matrixWidget(1,3)\nKw.setM(K)\n\n\neig1c = matrixWidget(1,1)\neig2c = matrixWidget(2,1)\neig3c = matrixWidget(1,1)\neig1c.setM(numpy.matrix([-3])) \neig2c.setM(numpy.matrix([[-30],[0]]))\neig3c.setM(numpy.matrix([-30]))\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= ['Nastavi K', 'Nastavi lastne vrednosti'],\n value= 'Nastavi K',\n description='',\n disabled=False\n)\n\n# Define the number of complex eigenvalues for the observer\nselc = widgets.Dropdown(\n options= ['brez kompleksnih lastnih vrednosti', 'dve kompleksni lastni vrednosti'],\n value= 'brez kompleksnih lastnih vrednosti',\n description='Lastne vrednosti:',\n disabled=False\n)\n\n#define type of ipout \nselu = widgets.Dropdown(\n options=['impulzna funkcija', 'koračna funkcija', 'sinusoidna funkcija', 'kvadratni val'],\n value='impulzna funkcija',\n description='Vhod:',\n disabled=False,\n style = {'description_width': 'initial','button_width':'180px'}\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='Referenca:',\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='Perioda: ',\n disabled=False,\n continuous_update=False,\n orientation='horizontal',\n readout=True,\n readout_format='.2f',\n)\n```\n\n\n```python\n# Support functions\n\ndef eigen_choice(selc):\n if selc == 'brez kompleksnih lastnih vrednosti':\n eig1c.children[0].children[0].disabled = False\n eig2c.children[1].children[0].disabled = True\n eigc = 0\n if selc == 'dve kompleksni lastni vrednosti':\n eig1c.children[0].children[0].disabled = True\n eig2c.children[1].children[0].disabled = False\n eigc = 2\n return eigc\n\ndef method_choice(selm):\n if selm == 'Nastavi K':\n method = 1\n selc.disabled = True\n if selm == 'Nastavi lastne vrednosti':\n method = 2\n selc.disabled = False\n return method\n```\n\n\n```python\ndef main_callback(Aw, Bw, Brw, X0w, K, eig1c, eig2c, eig3c, u, period, selm, selc, selu, DW):\n A, B, Br = Aw, Bw, Brw \n sols = numpy.linalg.eig(A)\n eigc = eigen_choice(selc)\n method = method_choice(selm)\n \n if method == 1:\n sol = numpy.linalg.eig(A-B*K)\n if method == 2:\n if eigc == 0:\n K = control.acker(A, B, [eig1c[0,0], eig2c[0,0], eig3c[0,0]])\n Kw.setM(K) \n if eigc == 2:\n K = control.acker(A, B, [eig1c[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 sol = numpy.linalg.eig(A-B*K)\n print('Lastne vrednosti sistema so:',round(sols[0][0],4),',',round(sols[0][1],4),'in',round(sols[0][2],4))\n print('Lastne vrednosti krmiljenega sistema so:',round(sol[0][0],4),',',round(sol[0][1],4),'in',round(sol[0][2],4))\n \n sys = sss(A-B*K,Br,C,0)\n T = numpy.linspace(0, 6, 1000)\n \n if selu == 'impulzna funkcija': #selu\n U = [0 for t in range(0,len(T))]\n U[0] = u\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n if selu == 'koračna funkcija':\n U = [u for t in range(0,len(T))]\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n if selu == 'sinusoidna funkcija':\n U = u*numpy.sin(2*numpy.pi/period*T)\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n if selu == 'kvadratni val':\n U = u*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n \n fig = plt.figure(num='Simulacija', figsize=(16,10))\n \n fig.add_subplot(211)\n plt.title('Odziv prve spremenljivke stanj')\n plt.ylabel('$X_1$ vs ref')\n plt.plot(T,xout[0],T,U,'r--')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_1$','Referenca'])\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(212)\n poles, zeros = control.pzmap(sys,Plot=False)\n plt.title('Diagram polov in ničel')\n plt.ylabel('Im')\n plt.plot(numpy.real(poles),numpy.imag(poles),'rx',numpy.real(zeros),numpy.imag(zeros),'bo')\n plt.xlabel('Re')\n plt.axvline(x=0,color='black',linewidth=0.8)\n plt.axhline(y=0,color='black',linewidth=0.8)\n plt.grid()\n \nalltogether = widgets.VBox([widgets.HBox([selm, \n selc, \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('Lastne vrednosti:',border=3), \n eig1c, \n eig2c, \n eig3c,\n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('X0:',border=3), X0w]),\n widgets.Label(' ',border=3),\n widgets.HBox([u, \n period, \n START]),\n widgets.Label(' ',border=3),\n widgets.HBox([widgets.Label('Dinamična matrika Aa:',border=3),\n Aw,\n widgets.Label('Vhodna matrika Ba:',border=3),\n Bw,\n widgets.Label('Referenčna matrika Br:',border=3),\n Brw])])\nout = widgets.interactive_output(main_callback, {'Aw':Aw, 'Bw':Bw, 'Brw':Brw, 'X0w':X0w, 'K':Kw, 'eig1c':eig1c, 'eig2c':eig2c, 'eig3c':eig3c, \n 'u':u, 'period':period, 'selm':selm, 'selc':selc, 'selu':selu, 'DW':DW})\nout.layout.height = '640px'\ndisplay(out, alltogether)\n```\n\n\n Output(layout=Layout(height='640px'))\n\n\n\n VBox(children=(HBox(children=(Dropdown(options=('Nastavi K', 'Nastavi lastne vrednosti'), value='Nastavi K'), …\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "45aeac29c77d827def00160b588980967680b7be", "size": 19921, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_si/examples/04/SS-31-Krmiljenje_povratne_zveze_stanj_zmogljivost.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/04/SS-31-Krmiljenje_povratne_zveze_stanj_zmogljivost.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/04/SS-31-Krmiljenje_povratne_zveze_stanj_zmogljivost.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": 38.6815533981, "max_line_length": 381, "alphanum_fraction": 0.4848150193, "converted": true, "num_tokens": 4195, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3998116264369279, "lm_q2_score": 0.2200070895174993, "lm_q1q2_score": 0.0879613922876462}} {"text": "# Optimización media-varianza\n\n\n\n\nLa **teoría de portafolios** es una de los avances más importantes en las finanzas modernas e inversiones.\n- Apareció por primera vez en un [artículo corto](https://www.math.ust.hk/~maykwok/courses/ma362/07F/markowitz_JF.pdf) llamado \"Portfolio Selection\" en la edición de Marzo de 1952 de \"the Journal of Finance\".\n- Escrito por un desconocido estudiante de la Universidad de Chicago, llamado Harry Markowitz.\n- Escrito corto (sólo 14 páginas), poco texto, fácil de entender, muchas gráficas y unas cuantas referencias.\n- No se le prestó mucha atención hasta los 60s.\n\nFinalmente, este trabajo se convirtió en una de las más grandes ideas en finanzas, y le dió a Markowitz el Premio Noble casi 40 años después.\n- Markowitz estaba incidentalmente interesado en los mercados de acciones e inversiones.\n- Estaba más bien interesado en entender cómo las personas tomaban sus mejores decisiones cuando se enfrentaban con \"trade-offs\".\n- Principio de conservación de la miseria. O, dirían los instructores de gimnasio: \"no pain, no gain\".\n- Si queremos más de algo, tenemos que perder en algún otro lado.\n- El estudio de este fenómeno era el que le atraía a Markowitz.\n\nDe manera que nadie se hace rico poniendo todo su dinero en la cuenta de ahorros. La única manera de esperar altos rendimientos es si se toma bastante riesgo. Sin embargo, riesgo significa también la posibilidad de perder, tanto como ganar.\n\nPero, ¿qué tanto riesgo es necesario?, y ¿hay alguna manera de minimizar el riesgo mientras se maximizan las ganancias?\n- Markowitz básicamente cambió la manera en que los inversionistas pensamos acerca de esas preguntas.\n- Alteró completamente la práctica de la administración de inversiones.\n- Incluso el título de su artículo era innovador. Portafolio: una colección de activos en lugar de tener activos individuales.\n- En ese tiempo, un portafolio se refería a una carpeta de cuero.\n- En el resto de este módulo, no ocuparemos de la parte analítica de la teoría de portafolios, la cual puede ser resumida en dos frases:\n - No pain, no gain.\n - No ponga todo el blanquillo en una sola bolsa.\n \n\n**Objetivos:**\n- ¿Qué es la línea de asignación de capital?\n- ¿Qué es el radio de Sharpe?\n- ¿Cómo deberíamos asignar nuestro capital entre un activo riesgoso y un activo libre de riesgo?\n\n*Referencia:*\n- Notas del curso \"Portfolio Selection and Risk Management\", Rice University, disponible en Coursera.\n___ \n\n## 1. Línea de asignación de capital\n\n### 1.1. Motivación\n\nEl proceso de construcción de un portafolio tiene entonces los siguientes dos pasos:\n1. Escoger un portafolio de activos riesgosos.\n2. Decidir qué tanto de tu riqueza invertirás en el portafolio y qué tanto invertirás en activos libres de riesgo.\n\nAl paso 2 lo llamamos **decisión de asignación de activos**.\n\nPreguntas importantes:\n1. ¿Qué es el portafolio óptimo de activos riesgosos?\n - ¿Cuál es el mejor portafolio de activos riesgosos?\n - Es un portafolio eficiente en media-varianza.\n2. ¿Qué es la distribución óptima de activos?\n - ¿Cómo deberíamos distribuir nuestra riqueza entre el portafolo riesgoso óptimo y el activo libre de riesgo?\n - Concepto de **línea de asignación de capital**.\n - Concepto de **radio de Sharpe**.\n\nDos suposiciones importantes:\n- Funciones de utilidad media-varianza.\n- Inversionista averso al riesgo.\n\nLa idea sorprendente que saldrá de este análisis, es que cualquiera que sea la actitud del inversionista de cara al riesgo, el mejor portafolio de activos riesgosos es idéntico para todos los inversionistas.\n\nLo que nos importará a cada uno de nosotros en particular, es simplemente la desición óptima de asignación de activos.\n___\n\n### 1.2. Línea de asignación de capital\n\nSean:\n- $r_s$ el rendimiento del activo riesgoso,\n- $r_f$ el rendimiento libre de riesgo, y\n- $w$ la fracción invertida en el activo riesgoso.\n\n Realizar deducción de la línea de asignación de capital en el tablero.\n\n**Tres doritos después...**\n\n#### Línea de asignación de capital (LAC):\n$E[r_p]$ se relaciona con $\\sigma_p$ de manera afín. Es decir, mediante la ecuación de una recta:\n\n$$E[r_p]=r_f+\\frac{E[r_s-r_f]}{\\sigma_s}\\sigma_p.$$\n\n- La pendiente de la LAC es el radio de Sharpe $\\frac{E[r_s-r_f]}{\\sigma_s}=\\frac{E[r_s]-r_f}{\\sigma_s}$,\n- el cual nos dice qué tanto rendimiento obtenemos por unidad de riesgo asumido en la tenencia del activo (portafolio) riesgoso.\n\nAhora, la pregunta es, ¿dónde sobre esta línea queremos estar?\n___\n\n### 1.3. Resolviendo para la asignación óptima de capital\n\nRecapitulando de la clase pasada, tenemos las curvas de indiferencia: **queremos estar en la curva de indiferencia más alta posible, que sea tangente a la LAC**.\n\n Ver en el tablero.\n\nAnalíticamente, el problema es\n\n$$\\max_{w} \\quad E[U(r_p)]\\equiv\\max_{w} \\quad E[r_p]-\\frac{1}{2}\\gamma\\sigma_p^2,$$\n\ndonde los puntos $(\\sigma_p,E[r_p])$ se restringen a estar en la LAC, esto es $E[r_p]=r_f+\\frac{E[r_s-r_f]}{\\sigma_s}\\sigma_p$ y $\\sigma_p=w\\sigma_s$. Entonces el problema anterior se puede escribir de la siguiente manera:\n\n$$\\max_{w} \\quad r_f+wE[r_s-r_f]-\\frac{1}{2}\\gamma w^2\\sigma_s^2.$$\n\n Encontrar la $w$ que maximiza la anterior expresión en el tablero.\n\n**Tres doritos después...**\n\nLa solución es entonces:\n\n$$w^\\ast=\\frac{E[r_s-r_f]}{\\gamma\\sigma_s^2}.$$\n\nDe manera intuitiva:\n- $w^\\ast\\propto E[r_s-r_f]$: a más exceso de rendimiento que se obtenga del activo riesgoso, más querremos invertir en él.\n- $w^\\ast\\propto \\frac{1}{\\gamma}$: mientras más averso al riesgo seas, menos querrás invertir en el activo riesgoso.\n- $w^\\ast\\propto \\frac{1}{\\sigma_s^2}$: mientras más riesgoso sea el activo, menos querrás invertir en él.\n___\n\n## 2. Ejemplo de asignación óptima de capital: acciones y billetes de EU\n\nPongamos algunos números con algunos datos, para ilustrar la derivación que acabamos de hacer.\n\nEn este caso, consideraremos:\n- **Portafolio riesgoso**: mercado de acciones de EU (representados en algún índice de mercado como el S&P500).\n- **Activo libre de riesgo**: billetes del departamento de tesorería de EU (T-bills).\n\nTenemos los siguientes datos:\n\n$$E[r_{US}]=11.9\\%,\\quad \\sigma_{US}=19.15\\%, \\quad r_f=1\\%.$$\n\nRecordamos que podemos escribir la expresión de la LAC como:\n\n\\begin{align}\nE[r_p]&=r_f+\\left[\\frac{E[r_{US}-r_f]}{\\sigma_{US}}\\right]\\sigma_p\\\\\n &=0.01+\\text{S.R.}\\sigma_p,\n\\end{align}\n\ndonde $\\text{S.R}=\\frac{0.119-0.01}{0.1915}\\approx0.569$ es el radio de Sharpe (¿qué es lo que es esto?).\n\nGrafiquemos la LAC con estos datos reales:\n\n\n```python\n# Importamos librerías que vamos a utilizar\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n```\n\n\n```python\n# Datos\nErus, sus, rf = 0.119, 0.1915, 0.01\n# Radio de Sharpe para este activo\nSR = (Erus-rf)/sus\n# Vector de volatilidades del portafolio\nsp = np.linspace(0, 0.5, 100)\n# LAC\nErp = rf+SR*sp\n```\n\n\n```python\n# Gráfica\nplt.figure(figsize=(10,6))\nplt.plot(sp, Erp, lw='3', label='LAC')\nplt.plot(0, rf, 'o', ms=10, label='Libre de riesgo')\nplt.plot(sus, Erus, 'o', ms=10, label='Portafolio riesgoso')\nplt.axhline(y=Erus, color='gray')\nplt.axvline(x=sus, color='gray')\nplt.axhline(y=0, color='k')\nplt.axvline(x=0, color='k')\nplt.grid()\nplt.xlabel('Volatility $\\sigma_p$')\nplt.ylabel('Expected return $E[r_p]$')\nplt.legend(loc='best')\n```\n\nBueno, y ¿en qué punto de esta línea querríamos estar?\n- Pues ya vimos que depende de tus preferencias.\n- En particular, de tu actitud de cara al riesgo, medido por tu coeficiente de aversión al riesgo.\n\nSolución al problema de asignación óptima de capital:\n\n$$\\max_{w} \\quad E[U(r_p)]$$\n\n$$w^\\ast=\\frac{E[r_s-r_f]}{\\gamma\\sigma_s^2}$$\n\nDado que ya tenemos datos, podemos intentar para varios coeficientes de aversión al riesgo:\n\n\n```python\n# importar pandas\nimport pandas as pd\n```\n\n\n```python\n# Crear un DataFrame con los pesos, rendimiento\n# esperado y volatilidad del portafolio óptimo \n# entre los activos riesgoso y libre de riesgo\n# cuyo índice sean los coeficientes de aversión\n# al riesgo del 1 al 10 (enteros)\ng = np.arange(1, 11)\nwopt = (Erus-rf)/(g*sus**2)\nsp = wopt*sus\nErp = rf+(Erus-rf)/sus*sp\ndata = pd.DataFrame(index=g, columns=['$w_{opt}$', '$E[r_p]$', '$\\sigma_p$'])\ndata.index.name = '$\\gamma$'\ndata['$w_{opt}$'] = wopt\ndata['$E[r_p]$'] = Erp\ndata['$\\sigma_p$'] = sp\ndata\n```\n\n\n\n\n| \n | $w_{opt}$ | \n$E[r_p]$ | \n$\\sigma_p$ | \n
|---|---|---|---|
| $\\gamma$ | \n\n | \n | \n |
| 1 | \n2.972275 | \n0.333978 | \n0.569191 | \n
| 2 | \n1.486137 | \n0.171989 | \n0.284595 | \n
| 3 | \n0.990758 | \n0.117993 | \n0.189730 | \n
| 4 | \n0.743069 | \n0.090994 | \n0.142298 | \n
| 5 | \n0.594455 | \n0.074796 | \n0.113838 | \n
| 6 | \n0.495379 | \n0.063996 | \n0.094865 | \n
| 7 | \n0.424611 | \n0.056283 | \n0.081313 | \n
| 8 | \n0.371534 | \n0.050497 | \n0.071149 | \n
| 9 | \n0.330253 | \n0.045998 | \n0.063243 | \n
| 10 | \n0.297227 | \n0.042398 | \n0.056919 | \n
Bruno Gonçalves
\n www.data4sci.com
\n @bgoncalves, @data4sci
| \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\n \n
\n\n- Aritmética de punto flotante no es conmutativa o asociativa\n\n\n- Errores de punto flotante compuestos, No asuma que la precisión doble es suficiente\n\n\n- Mezclar precisión es muy peligroso\n\n***EL ORDEN DE LOS FACTORES NO ALTERA EL PRODUCTO???***\n\n$$2 \\times 3 = 3 \\times 2 = 6$$\n\n\n$$ 10^{300} \\times 10^{50} \\times 10^{-60} = 10^{300} \\times 10^{-60} \\times 10^{50} ??$$\n\n\n\n```python\na = 10**300\nb = 10**10\nc = 10**-60\n\n```\n\n\n```python\nd1 = a * b * c\nprint(\"d1: \", d1)\n```\n\n\n```python\nd2 = b * c * a\nprint(\"d2: \", d2)\n\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 1: Aritmética simple\n\nAritmética simple $\\delta < \\epsilon_{\\text{machine}}$\n\n $$(1+\\delta) - 1 = 1 - 1 = 0$$\n\n $$1 - 1 + \\delta = \\delta$$\n\n\n```python\ndelta = 1.0000000001 * eps\n\nvalue = (1 + delta) - 1\nprint(value)\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 2: Cancelación catastrófica\n\nMiremos qué sucede cuando sumamos dos números $x$ y $y$ cuando $x+y \\neq 0$. De hecho, podemos estimar estos límites haciendo un análisis de error. Aquí necesitamos presentar la idea de que cada operación de punto flotante introduce un error tal que\n\n$$\n \\text{fl}(x ~\\text{op}~ y) = (x ~\\text{op}~ y) (1 + \\delta)\n$$\n\ndonde $\\text{fl}(\\cdot)$ es una función que devuelve la representación de punto flotante de la expresión encerrada, $\\text{op}$ es alguna operación (ex. $+, -, \\times, /$), y $\\delta$ es el error de punto flotante debido a $\\text{op}$.\n\nDe vuelta a nuestro problema en cuestión. El error de coma flotante debido a la suma es\n\n$$\\text{fl}(x + y) = (x + y) (1 + \\delta).$$\n\n\nComparando esto con la solución verdadera usando un error relativo tenemos\n\n$$\\begin{aligned}\n \\frac{(x + y) - \\text{fl}(x + y)}{x + y} &= \\frac{(x + y) - (x + y) (1 + \\delta)}{x + y} = \\delta.\n\\end{aligned}$$\n\nentonces si $\\delta = \\mathcal{O}(\\epsilon_{\\text{machine}})$ no estaremos muy preocupados.\n\nQue pasa si consideramos un error de punto flotante en la representación de $x$ y $y$, $x \\neq y$, y decimos que $\\delta_x$ y $\\delta_y$ son la magnitud de los errores en su representación. Asumiremos que esto constituye el error de punto flotante en lugar de estar asociado con la operación en sí.\n\nDado todo esto, tendríamos\n\n$$\\begin{aligned}\n \\text{fl}(x + y) &= x (1 + \\delta_x) + y (1 + \\delta_y) \\\\\n &= x + y + x \\delta_x + y \\delta_y \\\\\n &= (x + y) \\left(1 + \\frac{x \\delta_x + y \\delta_y}{x + y}\\right)\n\\end{aligned}$$\n\nCalculando nuevamente el error relativo, tendremos\n\n$$\\begin{aligned}\n \\frac{x + y - (x + y) \\left(1 + \\frac{x \\delta_x + y \\delta_y}{x + y}\\right)}{x + y} &= 1 - \\left(1 + \\frac{x \\delta_x + y \\delta_y}{x + y}\\right) \\\\\n &= \\frac{x}{x + y} \\delta_x + \\frac{y}{x + y} \\delta_y \\\\\n &= \\frac{1}{x + y} (x \\delta_x + y \\delta_y)\n\\end{aligned}$$\n\nLo importante aquí es que ahora el error depende de los valores de $x$ y $y$, y más importante aún, su suma. De particular preocupación es el tamaño relativo de $x + y$. A medida que se acerca a cero en relación con las magnitudes de $x$ y $y$, el error podría ser arbitrariamente grande. Esto se conoce como ***cancelación catastrófica***.\n\n\n```python\ndx = np.array([10**(-n) for n in range(1, 16)])\nx = 1.0 + dx\ny = -np.ones(x.shape)\nerror = np.abs(x + y - dx) / (dx)\n\nfig = plt.figure()\nfig.set_figwidth(fig.get_figwidth() * 2)\n\naxes = fig.add_subplot(1, 2, 1)\naxes.loglog(dx, x + y, 'o-')\naxes.set_xlabel(\"$\\Delta x$\")\naxes.set_ylabel(\"$x + y$\")\naxes.set_title(\"$\\Delta x$ vs. $x+y$\")\n\naxes = fig.add_subplot(1, 2, 2)\naxes.loglog(dx, error, 'o-')\naxes.set_xlabel(\"$\\Delta x$\")\naxes.set_ylabel(\"$|x + y - \\Delta x| / \\Delta x$\")\naxes.set_title(\"Diferencia entre $x$ y $y$ vs. Error relativo\")\n\nplt.show()\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 3: Evaluación de una función\n\nConsidere la función\n\n$$\n f(x) = \\frac{1 - \\cos x}{x^2}\n$$\n\ncon $x\\in[-10^{-4}, 10^{-4}]$. \n\nTomando el límite cuando $x \\rightarrow 0$ podemos ver qué comportamiento esperaríamos ver al evaluar esta función:\n\n$$\n \\lim_{x \\rightarrow 0} \\frac{1 - \\cos x}{x^2} = \\lim_{x \\rightarrow 0} \\frac{\\sin x}{2 x} = \\lim_{x \\rightarrow 0} \\frac{\\cos x}{2} = \\frac{1}{2}.\n$$\n\n¿Qué hace la representación de punto flotante?\n\n\n```python\nf = (1-np.cos(0))/0**2\n```\n\n\n```python\nx = np.linspace(-1e-3, 1e-3, 100, dtype=np.float32)\nerror = (0.5 - (1.0 - np.cos(x)) / x**2) / 0.5\n\nfig = plt.figure()\naxes = fig.add_subplot(1, 1, 1)\naxes.plot(x, error, 'o')\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"Error Relativo\")\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 4: Evaluación de un Polinomio\n\n $$f(x) = x^7 - 7x^6 + 21 x^5 - 35 x^4 + 35x^3-21x^2 + 7x - 1$$\n\n\n```python\nx = np.linspace(0.988, 1.012, 1000, dtype=np.float16)\ny = x**7 - 7.0 * x**6 + 21.0 * x**5 - 35.0 * x**4 + 35.0 * x**3 - 21.0 * x**2 + 7.0 * x - 1.0\n\nfig = plt.figure()\naxes = fig.add_subplot(1, 1, 1)\naxes.plot(x, y, 'r')\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"y\")\naxes.set_ylim((-0.1, 0.1))\naxes.set_xlim((x[0], x[-1]))\nplt.show()\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 5: Evaluación de una función racional\n\nCalcule $f(x) = x + 1$ por la función $$F(x) = \\frac{x^2 - 1}{x - 1}$$\n\n¿Cuál comportamiento esperarías encontrar?\n\n\n```python\nx = np.linspace(0.5, 1.5, 101, dtype=np.float16)\nf_hat = (x**2 - 1.0) / (x - 1.0)\n\nfig = plt.figure()\naxes = fig.add_subplot(1, 1, 1)\naxes.plot(x, np.abs(f_hat - (x + 1.0)))\naxes.set_xlabel(\"$x$\")\naxes.set_ylabel(\"Error Absoluto\")\nplt.show()\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n## Combinación de error\n\nEn general, nos debemos ocupar de la combinación de error de truncamiento con el error de punto flotante.\n\n- Error de Truncamiento: errores que surgen de la aproximación de una función, truncamiento de una serie.\n\n$$\\sin x \\approx x - \\frac{x^3}{3!} + \\frac{x^5}{5!} + O(x^7)$$\n\n\n- Error de punto flotante: errores derivados de la aproximación de números reales con números de precisión finita\n\n$$\\pi \\approx 3.14$$\n\no $\\frac{1}{3} \\approx 0.333333333$ en decimal, los resultados forman un número finito de registros para representar cada número.\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 1:\n\nConsidere la aproximación de diferencias finitas donde $f(x) = e^x$ y estamos evaluando en $x=1$\n\n$$f'(x) \\approx \\frac{f(x + \\Delta x) - f(x)}{\\Delta x}$$\n\nCompare el error entre disminuir $\\Delta x$ y la verdadera solucion $f'(1) = e$\n\n\n```python\ndelta_x = np.linspace(1e-20, 5.0, 100)\ndelta_x = np.array([2.0**(-n) for n in range(1, 60)])\nx = 1.0\nf_hat_1 = (np.exp(x + delta_x) - np.exp(x)) / (delta_x)\nf_hat_2 = (np.exp(x + delta_x) - np.exp(x - delta_x)) / (2.0 * delta_x)\n\nfig = plt.figure()\naxes = fig.add_subplot(1, 1, 1)\naxes.loglog(delta_x, np.abs(f_hat_1 - np.exp(1)), 'o-', label=\"Unilateral\")\naxes.loglog(delta_x, np.abs(f_hat_2 - np.exp(1)), 's-', label=\"Centrado\")\naxes.legend(loc=3)\naxes.set_xlabel(\"$\\Delta x$\")\naxes.set_ylabel(\"Error Absoluto\")\nplt.show()\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 2:\n\nEvalúe $e^x$ con la serie de *Taylor*\n\n$$e^x = \\sum^\\infty_{n=0} \\frac{x^n}{n!}$$\n\npodemos elegir $n< \\infty$ que puede aproximarse $e^x$ en un rango dado $x \\in [a,b]$ tal que el error relativo $E$ satisfaga $E<8 \\cdot \\varepsilon_{\\text{machine}}$?\n\n¿Cuál podría ser una mejor manera de simplemente evaluar el polinomio de Taylor directamente por varios $N$?\n\n\n```python\ndef my_exp(x, N=10):\n value = 0.0\n for n in range(N + 1):\n value += x**n / scipy.special.factorial(n)\n \n return value\n\nx = np.linspace(-2, 2, 100, dtype=np.float32)\nfor N in range(1, 50):\n error = np.abs((np.exp(x) - my_exp(x, N=N)) / np.exp(x))\n if np.all(error < 8.0 * np.finfo(float).eps):\n break\n\nprint(N)\n\nfig = plt.figure()\naxes = fig.add_subplot(1, 1, 1)\naxes.plot(x, error)\naxes.set_xlabel(\"x\")\naxes.set_ylabel(\"Error Relativo\")\nplt.show()\n```\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 3: Error relativo\n\nDigamos que queremos calcular el error relativo de dos valores $x$ y $y$ usando $x$ como valor de normalización\n\n$$\n E = \\frac{x - y}{x}\n$$\ny\n$$\n E = 1 - \\frac{y}{x}\n$$\n\nson equivalentes. En precisión finita, ¿qué forma pidría esperarse que sea más precisa y por qué?\n\nEjemplo tomado de [blog](https://nickhigham.wordpress.com/2017/08/14/how-and-how-not-to-compute-a-relative-error/) posteado por Nick Higham*\n\nUsando este modelo, la definición original contiene dos operaciones de punto flotante de manera que\n\n$$\\begin{aligned}\n E_1 = \\text{fl}\\left(\\frac{x - y}{x}\\right) &= \\text{fl}(\\text{fl}(x - y) / x) \\\\\n &= \\left[ \\frac{(x - y) (1 + \\delta_+)}{x} \\right ] (1 + \\delta_/) \\\\\n &= \\frac{x - y}{x} (1 + \\delta_+) (1 + \\delta_/)\n\\end{aligned}$$\n\nPara la otra formulación tenemos\n\n$$\\begin{aligned}\n E_2 = \\text{fl}\\left( 1 - \\frac{y}{x} \\right ) &= \\text{fl}\\left(1 - \\text{fl}\\left(\\frac{y}{x}\\right) \\right) \\\\\n &= \\left(1 - \\frac{y}{x} (1 + \\delta_/) \\right) (1 + \\delta_-)\n\\end{aligned}$$\n\nSi suponemos que todos las $\\text{op}$s tienen magnitudes de error similares, entonces podemos simplificar las cosas dejando que \n\n$$\n |\\delta_\\ast| \\le \\epsilon.\n$$\n\nPara comparar las dos formulaciones, nuevamente usamos el error relativo entre el error relativo verdadero $e_i$ y nuestras versiones calculadas $E_i$\n\nDefinición original\n\n$$\\begin{aligned}\n \\frac{e - E_1}{e} &= \\frac{\\frac{x - y}{x} - \\frac{x - y}{x} (1 + \\delta_+) (1 + \\delta_/)}{\\frac{x - y}{x}} \\\\\n &\\le 1 - (1 + \\epsilon) (1 + \\epsilon) = 2 \\epsilon + \\epsilon^2\n\\end{aligned}$$\n\nDefinición manipulada:\n\n$$\\begin{aligned}\n \\frac{e - E_2}{e} &= \\frac{e - \\left[1 - \\frac{y}{x}(1 + \\delta_/) \\right] (1 + \\delta_-)}{e} \\\\\n &= \\frac{e - \\left[e - \\frac{y}{x} \\delta_/) \\right] (1 + \\delta_-)}{e} \\\\\n &= \\frac{e - \\left[e + e\\delta_- - \\frac{y}{x} \\delta_/ - \\frac{y}{x} \\delta_/ \\delta_-)) \\right] }{e} \\\\\n &= - \\delta_- + \\frac{1}{e} \\frac{y}{x} \\left(\\delta_/ + \\delta_/ \\delta_- \\right) \\\\\n &= - \\delta_- + \\frac{1 -e}{e} \\left(\\delta_/ + \\delta_/ \\delta_- \\right) \\\\\n &\\le \\epsilon + \\left |\\frac{1 - e}{e}\\right | (\\epsilon + \\epsilon^2)\n\\end{aligned}$$\n\nVemos entonces que nuestro error de punto flotante dependerá de la magnitud relativa de $e$\n\n\n```python\n# Based on the code by Nick Higham\n# https://gist.github.com/higham/6f2ce1cdde0aae83697bca8577d22a6e\n# Compares relative error formulations using single precision and compared to double precision\n\nN = 501 # Note: Use 501 instead of 500 to avoid the zero value\nd = numpy.finfo(numpy.float32).eps * 1e4\na = 3.0\nx = a * numpy.ones(N, dtype=numpy.float32)\ny = [x[i] + numpy.multiply((i - numpy.divide(N, 2.0, dtype=numpy.float32)), d, dtype=numpy.float32) for i in range(N)]\n\n# Compute errors and \"true\" error\nrelative_error = numpy.empty((2, N), dtype=numpy.float32)\nrelative_error[0, :] = numpy.abs(x - y) / x\nrelative_error[1, :] = numpy.abs(1.0 - y / x)\nexact = numpy.abs( (numpy.float64(x) - numpy.float64(y)) / numpy.float64(x))\n\n# Compute differences between error calculations\nerror = numpy.empty((2, N))\nfor i in range(2):\n error[i, :] = numpy.abs((relative_error[i, :] - exact) / numpy.abs(exact))\n\nfig = plt.figure()\naxes = fig.add_subplot(1, 1, 1)\naxes.semilogy(y, error[0, :], '.', markersize=10, label=\"$|x-y|/|x|$\")\naxes.semilogy(y, error[1, :], '.', markersize=10, label=\"$|1-y/x|$\")\n\naxes.grid(True)\naxes.set_xlabel(\"y\")\naxes.set_ylabel(\"Error Relativo\")\naxes.set_xlim((numpy.min(y), numpy.max(y)))\naxes.set_ylim((5e-9, numpy.max(error[1, :])))\naxes.set_title(\"Comparasión Error Relativo\")\naxes.legend()\nplt.show()\n```\n\nAlgunos enlaces de utilidad con respecto al punto flotante IEEE:\n\n- [What Every Computer Scientist Should Know About Floating-Point Arithmetic](http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html)\n\n\n- [IEEE 754 Floating Point Calculator](http://babbage.cs.qc.edu/courses/cs341/IEEE-754.html)\n\n\n- [Numerical Computing with IEEE Floating Point Arithmetic](http://epubs.siam.org/doi/book/10.1137/1.9780898718072)\n\n[Volver a la Tabla de Contenido](#TOC)\n\n## Operaciones de conteo\n\n- ***Error de truncamiento:*** *¿Por qué no usar más términos en la serie de Taylor?*\n\n\n- ***Error de punto flotante:*** *¿Por qué no utilizar la mayor precisión posible?*\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 1: Multiplicación matriz - vector\n\nSea $A, B \\in \\mathbb{R}^{N \\times N}$ y $x \\in \\mathbb{R}^N$.\n\n1. Cuenta el número aproximado de operaciones que tomará para calcular $Ax$\n\n2. Hacer lo mismo para $AB$\n\n***Producto Matriz-vector:*** Definiendo $[A]_i$ como la $i$-ésima fila de $A$ y $A_{ij}$ como la $i$,$j$-ésima entrada entonces\n\n$$\n A x = \\sum^N_{i=1} [A]_i \\cdot x = \\sum^N_{i=1} \\sum^N_{j=1} A_{ij} x_j\n$$\n\nTomando un caso en particular, siendo $N=3$, entonces la operación de conteo es\n\n$$\n A x = [A]_1 \\cdot v + [A]_2 \\cdot v + [A]_3 \\cdot v = \\begin{bmatrix}\n A_{11} \\times v_1 + A_{12} \\times v_2 + A_{13} \\times v_3 \\\\\n A_{21} \\times v_1 + A_{22} \\times v_2 + A_{23} \\times v_3 \\\\\n A_{31} \\times v_1 + A_{32} \\times v_2 + A_{33} \\times v_3\n \\end{bmatrix}\n$$\n\nEsto son 15 operaciones (6 sumas y 9 multiplicaciones)\n\nTomando otro caso, siendo $N=4$, entonces el conteo de operaciones es:\n\n$$\n A x = [A]_1 \\cdot v + [A]_2 \\cdot v + [A]_3 \\cdot v = \\begin{bmatrix}\n A_{11} \\times v_1 + A_{12} \\times v_2 + A_{13} \\times v_3 + A_{14} \\times v_4 \\\\\n A_{21} \\times v_1 + A_{22} \\times v_2 + A_{23} \\times v_3 + A_{24} \\times v_4 \\\\\n A_{31} \\times v_1 + A_{32} \\times v_2 + A_{33} \\times v_3 + A_{34} \\times v_4 \\\\\n A_{41} \\times v_1 + A_{42} \\times v_2 + A_{43} \\times v_3 + A_{44} \\times v_4 \\\\\n \\end{bmatrix}\n$$\n\nEsto lleva a 28 operaciones (12 sumas y 16 multiplicaciones).\n\nGeneralizando, hay $N^2$ mutiplicaciones y $N(N-1)$ sumas para un total de \n\n$$\n \\text{operaciones} = N (N - 1) + N^2 = \\mathcal{O}(N^2).\n$$\n\n***Producto Matriz-Matriz ($AB$):*** Definiendo $[B]_j$ como la $j$-ésima columna de $B$ entonces\n\n$$\n (A B)_{ij} = \\sum^N_{i=1} \\sum^N_{j=1} [A]_i \\cdot [B]_j\n$$\n\nEl producto interno de dos vectores es representado por \n\n$$\n a \\cdot b = \\sum^N_{i=1} a_i b_i\n$$\n\nconduce a $\\mathcal{O}(3N)$ operaciones. Como hay $N^2$ entradas en la matriz resultante, tendríamos $\\mathcal{O}(N^3)$ operaciones\n\nExisten métodos para realizar la multiplicación matriz - matriz más rápido. En la siguiente figura vemos una colección de algoritmos a lo largo del tiempo que han podido limitar el número de operaciones en ciertas circunstancias\n$$\n \\mathcal{O}(N^\\omega)\n$$\n\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Ejemplo 2: Método de Horner para evaluar polinomios\n\nDado\n\n$$P_N(x) = a_0 + a_1 x + a_2 x^2 + \\ldots + a_N x^N$$ \n\no\n\n\n$$P_N(x) = p_1 x^N + p_2 x^{N-1} + p_3 x^{N-2} + \\ldots + p_{N+1}$$\n\nqueremos encontrar la mejor vía para evaluar $P_N(x)$\n\nPrimero considere dos vías para escribir $P_3$\n\n$$ P_3(x) = p_1 x^3 + p_2 x^2 + p_3 x + p_4$$\n\ny usando multiplicación anidada\n\n$$ P_3(x) = ((p_1 x + p_2) x + p_3) x + p_4$$\n\nConsidere cuántas operaciones se necesitan para cada...\n\n$$ P_3(x) = p_1 x^3 + p_2 x^2 + p_3 x + p_4$$\n\n$$P_3(x) = \\overbrace{p_1 \\cdot x \\cdot x \\cdot x}^3 + \\overbrace{p_2 \\cdot x \\cdot x}^2 + \\overbrace{p_3 \\cdot x}^1 + p_4$$\n\nSumando todas las operaciones, en general podemos pensar en esto como una pirámide\n\n\n\npodemos estimar de esta manera que el algoritmo escrito de esta manera tomará aproximadamente $\\mathcal{O}(N^2/2)$ operaciones para completar.\n\nMirando nuetros otros medios de evaluación\n\n$$ P_3(x) = ((p_1 x + p_2) x + p_3) x + p_4$$\n\nAquí encontramos que el método es $\\mathcal{O}(N)$ (el 2 generalmente se ignora en estos casos). Lo importante es que la primera evaluación es $\\mathcal{O}(N^2)$ y la segunda $\\mathcal{O}(N)$!\n\n[Volver a la Tabla de Contenido](#TOC)\n\n### Algoritmo\n\nComplete la función e implemente el método de *Horner*\n\n```python\ndef eval_poly(p, x):\n \"\"\"Evaluates polynomial given coefficients p at x\n \n Function to evaluate a polynomial in order N operations. The polynomial is defined as\n \n P(x) = p[0] x**n + p[1] x**(n-1) + ... + p[n-1] x + p[n]\n \n The value x should be a float.\n \"\"\"\n pass\n```\n\n\n```python\ndef eval_poly(p, x):\n \"\"\"Evaluates polynomial given coefficients p at x\n \n Function to evaluate a polynomial in order N operations. The polynomial is defined as\n \n P(x) = p[0] x**n + p[1] x**(n-1) + ... + p[n-1] x + p[n]\n \n The value x should be a float.\n \"\"\"\n ### ADD CODE HERE\n pass\n```\n\n\n```python\n# Scalar version\ndef eval_poly(p, x):\n \"\"\"Evaluates polynomial given coefficients p at x\n \n Function to evaluate a polynomial in order N operations. The polynomial is defined as\n \n P(x) = p[0] x**n + p[1] x**(n-1) + ... + p[n-1] x + p[n]\n \n The value x should be a float.\n \"\"\"\n \n y = p[0]\n for coefficient in p[1:]:\n y = y * x + coefficient\n \n return y\n\n# Vectorized version\ndef eval_poly(p, x):\n \"\"\"Evaluates polynomial given coefficients p at x\n \n Function to evaluate a polynomial in order N operations. The polynomial is defined as\n \n P(x) = p[0] x**n + p[1] x**(n-1) + ... + p[n-1] x + p[n]\n \n The value x can by a NumPy ndarray.\n \"\"\"\n \n y = numpy.ones(x.shape) * p[0]\n for coefficient in p[1:]:\n y = y * x + coefficient\n \n return y\n\np = [1, -3, 10, 4, 5, 5]\nx = numpy.linspace(-10, 10, 100)\nplt.plot(x, eval_poly(p, x))\nplt.show()\n```\n\n[Volver a la Tabla de Contenido](#TOC)\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```python\n\n```\n", "meta": {"hexsha": "ce03d631c4df06573f64bec7e27cb7cb115ea0f8", "size": 163327, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Cap01_Error.ipynb", "max_stars_repo_name": "carlosalvarezh/Analisis_Numerico", "max_stars_repo_head_hexsha": "4a6aed7cf18832e81e731352ed279bd381cfd7a6", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-09-24T17:53:50.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-24T17:53:50.000Z", "max_issues_repo_path": "Cap01_Error.ipynb", "max_issues_repo_name": "carlosalvarezh/Analisis_Numerico", "max_issues_repo_head_hexsha": "4a6aed7cf18832e81e731352ed279bd381cfd7a6", "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": "Cap01_Error.ipynb", "max_forks_repo_name": "carlosalvarezh/Analisis_Numerico", "max_forks_repo_head_hexsha": "4a6aed7cf18832e81e731352ed279bd381cfd7a6", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4, "max_forks_repo_forks_event_min_datetime": "2021-01-28T21:22:28.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-11T17:53:02.000Z", "avg_line_length": 66.8550961932, "max_line_length": 26748, "alphanum_fraction": 0.7665052318, "converted": true, "num_tokens": 15925, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34158248603300034, "lm_q2_score": 0.2509127812837603, "lm_q1q2_score": 0.08570741160836133}} {"text": "```python\nfrom IPython.display import display, Image\n\n```\n\n# Introduction to Gradient Boosting Methods (GBMs)\n\nWe note that the following content mainly builds upon [Introduction to Boosted Trees](https://xgboost.readthedocs.io/en/stable/tutorials/model.html).\n\nThe technique of gradient boosting which has attracted significantly increasing attention in recent years due to its superior for solving\ntabular data problems. The term **Gradient Boosting** originates from the paper *Greedy Function Approximation: A Gradient Boosting Machine*, by Friedman. This tutorial aims to provide a clear explanation on typical gradient boosting methods, such as gradient boosting decision trees (GBDT), in a self-contained and principled way using the elements of supervised learning.\n\n## 1 Elements of Supervised Learning\n\nFirst, we introduce the notations used throughout this tutorial as follows:\n\nGiven the training data $X=\\{\\mathbf{x}_i\\}_{i=1}^{n}$, and the target $Y=\\{y_i\\}_{i=1}^{n}$, where $\\mathbf{x}_i$ denotes the feature vector with respect to the $i$-th data instance, which can be either continuous or categorical features. $\\mathbf{x}_{ij}$ denotes the $j$-th feature of $\\mathbf{x}_i$.\n\n### 1.1 Model and Parameters\nThe **model** in supervised learning usually refers to the mathematical structure by which the prediction $\\hat{y}_{i}$ is made given the input $\\mathbf{x}_i$. A common example is a **linear model**, where the prediction is given as $\\hat{y}_i = \\sum_j \\theta_j \\mathbf{x}_{ij}$, namely a linear combination of weighted input features. The prediction value can have different interpretations, depending on the task, i.e., regression or classification. For example, it can be logistic transformed to get the probability of positive class in logistic regression, and it can also be used as a ranking score when we want to rank the outputs.\n\nThe **parameters** are the undetermined part that we need to learn from data. In linear regression problems, the parameters are the coefficients $\\theta$. Usually we will use $\\theta$ to denote the parameters.\n\n### 1.2 Objective Function: Training Loss + Regularization\nWith judicious choices for $y_i$, we may express a variety of tasks, such as regression, classification, and ranking.\nThe task of **training** the model amounts to finding the best parameters $\\theta$ that best fit the training data $\\mathbf{x}_i$ and labels $y_i$. In order to train the model, we need to define the **objective function**\nto measure how well the model fit the training data.\n\nA salient characteristic of objective functions is that they consist two parts: **training loss** and **regularization term**:\n\n\\begin{equation}\n\\text{obj}(\\theta) = L(\\theta) + \\Omega(\\theta)\n\\end{equation}\n\nwhere $L$ is the training loss function, and $\\Omega$ is\nthe **regularization term**. The training loss measures how *predictive* our model is with respect to the training data. A common choice of $L$ is the *mean squared error*, which is given by\n\n$L(\\theta) = \\sum_i (y_i-\\hat{y}_i)^2$\n\nAnother commonly used loss function is logistic loss, to be used for logistic regression:\n\n$$L(\\theta) = \\sum_i[ y_i\\ln (1+e^{-\\hat{y}_i}) + (1-y_i)\\ln (1+e^{\\hat{y}_i})]$$\n\nThe **regularization term** is what people usually forget to add. The regularization term controls the complexity of the model, which helps us to avoid overfitting.\n\n### 1.3 Why introduce the general principle?\nThe elements introduced above form the basic elements of supervised learning, and they are natural building blocks of machine learning toolkits. For example, you should be able to describe the differences and commonalities between gradient boosted trees and random forests. Understanding the process in a formalized way also helps us to understand the objective that we are learning and the reason behind the heuristics such as pruning and smoothing.\n\n## 2 Gradient Boosting Decision Trees (GBDT)\n\n### 2.1 Tree Ensembles\nNow that we have introduced the elements of supervised learning, let us get started with real trees. The tree ensemble model consists of a set of classification and regression trees (CART). Here's a simple example of a CART that classifies whether someone will like a hypothetical computer game X.\n\nFig. A toy example for CART\n\n\nWe classify the members of a family into different leaves, and assign them the score on the corresponding leaf.\nA CART is a bit different from decision trees, in which the leaf only contains decision values. In CART, a real score\nis associated with each of the leaves, which gives us richer interpretations that go beyond classification.\nThis also allows for a principled, unified approach to optimization, as we will see in a later part of this tutorial.\n\nUsually, a single tree is not strong enough to be used in practice. What is actually used is the ensemble model,\nwhich sums the prediction of multiple trees together.\n\nFig. A toy example for tree ensemble, consisting of two CARTs\n\n\nHere is an example of a tree ensemble of two trees. The prediction scores of each individual tree are summed up to get the final score.\nIf you look at the example, an important fact is that the two trees try to **complement** each other.\nMathematically, we can write our model in the form\n\n$$\\hat{y}_i = \\sum_{k=1}^K f_k(x_i), f_k \\in \\mathcal{F}$$\n\nwhere $K$ is the number of trees, $f$ is a function in the functional space $\\mathcal{F}$, and $\\mathcal{F}$ is the set of all possible CARTs. The objective function to be optimized is given by\n\n$$\\text{obj}(\\theta) = \\sum_i^n l(y_i, \\hat{y}_i) + \\sum_{k=1}^K \\Omega(f_k)$$\n\nNow here comes a trick question: what is the **model** used in random forests? Tree ensembles! So random forests and boosted trees are really the same models; the difference arises from how we train them. This means that, if you write a predictive service for tree ensembles, you only need to write one and it should work for both random forests and gradient boosted trees. (See [Treelite](https://treelite.readthedocs.io/en/latest/index.html) for an actual example.) One example of why elements of supervised learning rock.\n\n### 2.2 Tree Boosting\n\nNow that we introduced the model, let us turn to training: How should we learn the trees?\nThe answer is, as is always for all supervised learning models: **define an objective function and optimize it**!\n\nLet the following be the objective function (remember it always needs to contain training loss and regularization):\n\n$$\\text{obj} = \\sum_{i=1}^n l(y_i, \\hat{y}_i^{(t)}) + \\sum_{i=1}^t\\Omega(f_i)$$\n\nIn particular, $t$ denotes the training step, each step also corresponds to a member function $f$, i.e., a tree.\n\n### 2.3 Additive Training\n\nThe first question we want to ask: what are the **parameters** of trees? You can find that what we need to learn are those functions $f_i$, **each containing the structure of the tree and the leaf scores**. Learning tree structure is much harder than traditional optimization problem where you can simply take the gradient. **It is intractable to learn all the trees at once**.\nInstead, we use an **additive strategy: fix what we have learned, and add one new tree at a time**. In other words, the functions $f_1$ ... $f_{t-1}$ would be viewed as learned functions when we learn $f_t$. We write the prediction value at **step** $t$ as $\\hat{y}_i^{(t)}$. Then we have\n\n\\begin{equation}\n\\begin{split}\n\\hat{y}_i^{(0)} &= 0\\\\\n \\hat{y}_i^{(1)} &= f_1(x_i) = \\hat{y}_i^{(0)} + f_1(x_i)\\\\\n \\hat{y}_i^{(2)} &= f_1(x_i) + f_2(x_i)= \\hat{y}_i^{(1)} + f_2(x_i)\\\\\n &\\dots\\\\\n \\hat{y}_i^{(t)} &= \\sum_{k=1}^t f_k(x_i)= \\hat{y}_i^{(t-1)} + f_t(x_i)\n\\end{split}\n\\end{equation}\n\nIt remains to ask: which tree do we want at each step? A natural thing is to add the one that optimizes our objective.\n\n\\begin{equation}\n\\begin{split}\n \\text{obj}^{(t)} & = \\sum_{i=1}^n l(y_i, \\hat{y}_i^{(t)}) + \\sum_{i=1}^t\\Omega(f_i) \\\\\n & = \\sum_{i=1}^n l(y_i, \\hat{y}_i^{(t-1)} + f_t(x_i)) + \\Omega(f_t) + \\mathrm{constant}\n\\end{split}\n\\end{equation}\n\nIf we consider using mean squared error (MSE) as our loss function, the objective becomes\n\n\\begin{equation}\n\\begin{split}\n \\text{obj}^{(t)} & = \\sum_{i=1}^n (y_i - (\\hat{y}_i^{(t-1)} + f_t(x_i)))^2 + \\sum_{i=1}^t\\Omega(f_i) \\\\\n & = \\sum_{i=1}^n [2(\\hat{y}_i^{(t-1)} - y_i)f_t(x_i) + f_t(x_i)^2] + \\Omega(f_t) + \\mathrm{constant}\n\\end{split}\n\\end{equation}\n\nwhere the terms without $f_t$ are aggregated as a constant since the functions $f_1$ ... $f_{t-1}$ are learned functions in previous steps.\n\n> In calculus, Taylor's theorem gives an approximation of a k-times\ndifferentiable function around a given point by a polynomial of degree\nk, called the kth-order Taylor polynomial. For a smooth function,\nthe Taylor polynomial is the truncation at the order k of the Taylor\nseries of the function.\n>\n> \\begin{equation}\nf(x)=\\sum_{n=0}^{\\infty}\\frac{f^{(n)}(x_{0})}{n!}(x-x_{0})^{n}\n\\end{equation}\n>\n> The first-order Taylor polynomial is the linear approximation of the\nfunction,\n>\n> $f(x)\\approx f(x_{0})+f^{'}(x_{0})(x-x_{0})$\n>\n>The second-order Taylor polynomial is often referred to as the quadratic\napproximation,\n>\n>$f(x)\\approx f(x_{0})+f^{'}(x_{0})(x-x_{0})+f^{''}(x_{0})\\frac{(x-x_{0})^{2}}{2}$\n\nThe form of MSE is friendly, with a first order term (usually called the residual) and a quadratic term.\nFor other losses of interest (for example, logistic loss), it is not so easy to get such a nice form.\nSo in the general case, we take the **Taylor expansion of the loss function up to the second order**:\n\n\\begin{equation}\n\\begin{split}\n \\text{obj}^{(t)} = \\sum_{i=1}^n [l(y_i, \\hat{y}_i^{(t-1)}) + g_i f_t(x_i) + \\frac{1}{2} h_i f_t^2(x_i)] + \\Omega(f_t) + \\mathrm{constant}\n\\end{split}\n\\end{equation}\n\nwhere the $g_i$ and $h_i$ are defined as\n\n\\begin{equation}\n\\begin{split}\n g_i &= \\partial_{\\hat{y}_i^{(t-1)}} l(y_i, \\hat{y}_i^{(t-1)})\\\\\n h_i &= \\partial_{\\hat{y}_i^{(t-1)}}^2 l(y_i, \\hat{y}_i^{(t-1)})\n\\end{split}\n\\end{equation}\n\n> We note that the $f$ in the description on Taylor's theorem is different from $f_{t}$ in the loss function. Put another way, $g_i$ corresponds to $f^{'}(x_{0})$, $h_i$ corresponds to $f^{''}(x_{0})$, $f_t(x_i)$ corresponds to $x-x_{0}$, $\\sum_{i=1}^n l(y_i, \\hat{y}_i^{(t-1)})$ corresponds to $f(x_{0})$.\n\nAfter we remove all the constants, the specific objective at step $t$ becomes\n\n\\begin{equation}\n\\begin{split}\n \\sum_{i=1}^n [g_i f_t(x_i) + \\frac{1}{2} h_i f_t^2(x_i)] + \\Omega(f_t)\n\\end{split}\n\\end{equation}\n\n**This becomes our optimization goal for the new tree**. One important advantage of this definition is that\nthe value of the objective function only depends on $g_i$ and $h_i$. This is how the popular packages, such as **XGBoost** and **LightGBM**, support custom loss functions.\n**We can optimize every loss function, including logistic regression and pairwise ranking, using exactly the same solver that takes $g_i$ and $h_i$ as input**!\n\n### 2.4 Model Complexity\nWe have introduced the training step, but wait, there is one important thing, the **regularization term**!\nWe need to define the complexity of the tree $\\Omega(f)$. In order to do so, let us first refine the definition of the tree $f(x)$ as\n\n\\begin{equation}\n\\begin{split}\n f_t(x) = w_{q(x)}, w \\in R^T, q:R^d\\rightarrow \\{1,2,\\cdots,T\\} .\n\\end{split}\n\\end{equation}\n\nHere $w$ is the vector of scores on leaves, $q$ is a function assigning each data point to the corresponding leaf, and $T$ is the number of leaves.\nIn XGBoost, the complexity is defined as\n\n\\begin{equation}\n\\begin{split}\n \\Omega(f) = \\gamma T + \\frac{1}{2}\\lambda \\sum_{j=1}^T w_j^2\n\\end{split}\n\\end{equation}\n\nOf course, there is more than one way to define the complexity, but this one works well in practice. The regularization is one part most tree packages treat\nless carefully, or simply ignore. This was because the traditional treatment of tree learning only emphasized improving impurity, while the complexity control was left to heuristics.\nBy defining it formally, we can get a better idea of what we are learning and obtain models that perform well in the wild.\n\n### 2.5 The Structure Score\nHere is the magical part of the derivation. After re-formulating the tree model, we can write the objective value with the $t$-th tree as:\n\n\\begin{equation}\n\\begin{split}\n \\text{obj}^{(t)} &\\approx \\sum_{i=1}^n [g_i w_{q(x_i)} + \\frac{1}{2} h_i w_{q(x_i)}^2] + \\gamma T + \\frac{1}{2}\\lambda \\sum_{j=1}^T w_j^2\\\\\n &= \\sum^T_{j=1} [(\\sum_{i\\in I_j} g_i) w_j + \\frac{1}{2} (\\sum_{i\\in I_j} h_i + \\lambda) w_j^2 ] + \\gamma T\n\\end{split}\n\\end{equation}\n\nwhere $I_j = \\{i|q(x_i)=j\\}$ is the set of indices of data points assigned to the $j$-th leaf.\nNotice that in the second line we have changed the index of the summation because all the data points on the same leaf get the same score.\nWe could further compress the expression by defining $G_j = \\sum_{i\\in I_j} g_i$ and $H_j = \\sum_{i\\in I_j} h_i$:\n\n\\begin{equation}\n\\begin{split}\n \\text{obj}^{(t)} = \\sum^T_{j=1} [G_jw_j + \\frac{1}{2} (H_j+\\lambda) w_j^2] +\\gamma T\n\\end{split}\n\\end{equation}\n\nIn this equation, $w_j$ are independent with respect to each other, the form $G_jw_j+\\frac{1}{2}(H_j+\\lambda)w_j^2$ is quadratic and the best $w_j$ for a given structure $q(x)$ and the best objective reduction we can get is:\n\n\\begin{equation}\n\\begin{split}\n w_j^\\ast &= -\\frac{G_j}{H_j+\\lambda}\\\\\n \\text{obj}^\\ast &= -\\frac{1}{2} \\sum_{j=1}^T \\frac{G_j^2}{H_j+\\lambda} + \\gamma T\n\\end{split}\n\\end{equation}\n\nThe last equation measures *how good* a tree structure $q(x)$ is.\n\nFig. An illustration of structure score (fitness)\n\n\n\nIf all this sounds a bit complicated, let's take a look at the picture, and see how the scores can be calculated.\nBasically, for a given tree structure, we push the statistics $g_i$ and $h_i$ to the leaves they belong to,\nsum the statistics together, and use the formula to calculate how good the tree is.\nThis score is like the impurity measure in a decision tree, except that it also takes the model complexity into account.\n\n### 2.6 Learn the tree structure\nNow that we have a way to measure how good a tree is, ideally we would enumerate all possible trees and pick the best one.\nIn practice this is intractable, so we will try to optimize one level of the tree at a time.\nSpecifically we try to split a leaf into two leaves, and the score it gains is\n\n\\begin{equation}\n\\begin{split}\n Gain = \\frac{1}{2} \\left[\\frac{G_L^2}{H_L+\\lambda}+\\frac{G_R^2}{H_R+\\lambda}-\\frac{(G_L+G_R)^2}{H_L+H_R+\\lambda}\\right] - \\gamma\n\\end{split}\n\\end{equation}\n\nThis formula can be decomposed as: 1) the score on the new left leaf, 2) the score on the new right leaf, 3) the score on the original leaf, 4) regularization on the additional leaf.\nWe can see an important fact here: if the gain is smaller than $\\gamma$, we would do better not to add that branch. This is exactly the **pruning** techniques in tree based models! By using the principles of supervised learning, we can naturally come up with the reason these techniques work :)\n\n### 2.7 Approximate Split Finding Using Feature Histograms\n\nIt is vital to find the optimal split of a tree node efficiently, as enumerating every possible split in a brute-force manner is impractical. Current works generally adopt a histogram-based algorithm for\nfast and accurate split finding, like the following picture.\n\n\n```python\npath_img_his = \"../img/histogram_split.png\"\nimg_ltr_perqdata = Image(path_img_his, width = 800, height = 100)\ndisplay(img_ltr_perqdata)\n```\n\nSpecifically, the algorithm considers only $k$ values (i.e., number of bins) for each feature as candidate splits rather than all possible splits (e.g., all feature values). The most common approach to propose the candidates is using the **quantile sketch** to approximate the feature distribution. After candidate splits are prepared, we enumerate\nall instances on a tree node and accumulate their gradient statistics into two histograms, first- and second-order gradients, respectively. The histogram consists of $k$ bins, each of which sums the first- or second-order gradients of instances whose $j$-th feature values fall into that bin. In this way, each feature is summarized by two histograms. We find the best split of $j$-th feature upon the histograms that achieve the maximum gain value and the global best split is the best split over all features.\n\nAnother advantage of the histogram-based algorithm is that we can accelerate the algorithm by a histogram subtraction technique. The instances on two children nodes are **non-overlapping and mutual exclusive**, since **an instance will be classified onto either left or right child node when the parent node gets split** (since the bins or histograms are naturally ordered). Considering the basic operation of histogram is adding gradients, therefore, for a specific feature, the element-wise sum of first or second-order histograms of children nodes equals to that of parent.\n\n- Example case: using local bins\n\n Motivated by this, we can significantly accelerate training by first constructing the histograms of the one child node with fewer instances, and then getting those of the sibling node via histogram subtraction (histograms of parent node are persist in memory). By doing so, we can skip at least one half of the instances. Since histogram construction usually dominates the computation cost, such subtraction technique can speed up the training process considerably.\n\n> Limitation of additive tree learning\n\n Since it is intractable to enumerate all possible tree structures, we add one split at a time. This approach works well most of the time, but there are some edge cases that fail due to this approach. For those edge cases, training results in a degenerate model because we consider only one feature dimension at a time. See [Can Gradient Boosting Learn Simple Arithmetic?](\n\n# Getting Started with Python and Jupyter Notebooks\n\n## Summary\n\nThe purpose of this [Jupyter Notebook](http://jupyter.org/) is to get you started using Python and Jupyter Notebooks for routine chemical engineering calculations. This introduction assumes this is your first exposure to Python or Jupyter notebooks.\n\n## Step 0: Gain Executable Access to Jupyter Notebooks\n\nJupyter notebooks are documents that can be viewed and executed inside any modern web browser. Since you're reading this notebook, you already know how to view a Jupyter notebook. The next step is to learn how to execute computations that may be embedded in a Jupyter notebook.\n\nTo execute Python code in a notebook you will need access to a Python kernal. A kernal is simply a program that runs in the background, maintains workspace memory for variables and functions, and executes Python code. The kernal can be located on the same laptop as your web browser or located in an on-line cloud service. \n\n**Important Note Regarding Versions** There are two versions of Python in widespread use. Version 2.7 released in 2010, which was the last release of the 2.x series. Version 3.5 is the most recent release of the 3.x series which represents the future direction of language. It has taken years for the major scientific libraries to complete the transition from 2.x to 3.x, but it is now safe to recommend Python 3.x for widespread use. So for this course be sure to use latest verstion, currently 3.6, of the Python language.\n\n### Using Jupyter/Python in the Cloud\n\nThe easiest way to use Jupyter notebooks is to sign up for a free or paid account on a cloud-based service such as [Wakari.io](https://www.wakari.io/) or [SageMathCloud](https://cloud.sagemath.com/). You will need continuous internet connectivity to access your work, but the advantages are there is no software to install or maintain. All you need is a modern web browser on your laptop, Chromebook, tablet or other device. Note that the free services are generally heavily oversubscribed, so you should consider a paid account to assure access during prime hours.\n\nThere are also demonstration sites in the cloud, such as [tmpnb.org](https://tmpnb.org/). These start an interactive session where you can upload an existing notebook or create a new one from scratch. Though convenient, these sites are intended mainly for demonstration and generally quite overloaded. More significantly, there is no way to retain your work between sessions, and some python functionality is removed for security reasons.\n\n### Installing Jupyter/Python on your Laptop\n\nFor regular off-line use you should consider installing a Jupyter Notebook/Python environment directly on your laptop. This will provide you with reliable off-line access to a computational environment. This will also allow you to install additional code libraries to meet particular needs. \n\nChoosing this option will require an initial software installation and routine updates. For this course the recommended package is [Anaconda](https://store.continuum.io/cshop/anaconda/) available from [Continuum Analytics](http://continuum.io/). Downloading and installing the software is well documented and easy to follow. Allow about 10-30 minutes for the installation depending on your connection speed. \n\nAfter installing be sure to check for updates before proceeding further. With the Anaconda package this is done by executing the following two commands in a terminal window:\n\n > conda update conda\n > conda update anaconda\n\nAnaconda includes an 'Anaconda Navigator' application that simplifies startup of the notebook environment and manage the update process.\n\n## Step 1: Start a Jupyter Notebook Session\n\nIf you are using a cloud-based service a Jupyter session will be started when you log on. \n\nIf you have installed a Jupyter/Python distribution on your laptop then you can open a Jupyter session in one of two different ways:\n\n* Use the Anaconda Navigator App, or \n* open a terminal window on your laptop and execute the following statement at the command line:\n\n > jupyter notebook\n\nEither way, once you have opened a session you should see a browser window like this:\n\n\n\nAt this point the browser displays a list of directories and files. You can navigate amoung the directories in the usual way by clicking on directory names or on the 'breadcrumbs' located just about the listing. \n\nJupyter notebooks are simply files in a directory with a `.ipynb` suffix. They can be stored in any directory including Dropbox or Google Drive. Upload and create new Jupyter notebooks in the displayed directory using the appropriate buttons. Use the checkboxes to select items for other actions, such as to duplicate, to rename, or to delete notebooks and directories.\n\n* select one of your existing notebooks to work on,\n* start a new notebook by clicking on the `New Notebook` button, or \n* import a notebook from another directory by dragging it onto the list of notebooks.\n\nAn IPython notebook consists of cells that hold headings, text, or python code. The user interface is relatively self-explanatory. Take a few minutes now to open, rename, and save a new notebook. \n\nHere's a quick video overview of Jupyter notebooks.\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo(\"HW29067qVWk\",560,315,rel=0)\n```\n\n\n\n\n\n\n\n\n\n\n## Step 2: Simple Calculations with Python\n\nPython is an elegant and modern language for programming and problem solving that has found increasing use by engineers and scientists. In the next few cells we'll demonstrate some basic Python functionality.\n\n### Basic Arithmetic Operations\n\nBasic arithmetic operations are built into the Python langauge. Here are some examples. In particular, note that exponentiation is done with the \\*\\* operator.\n\n\n```python\na = 12\nb = 2\n\nprint(a + b)\nprint(a**b)\nprint(a/b)\n```\n\n 14\n 144\n 6.0\n\n\n### Python Libraries\n\nThe Python language has only very basic operations. Most math functions are in various math libraries. The `numpy` library is convenient library. This next cell shows how to import `numpy` with the prefix `np`, then use it to call a common mathematical functions.\n\n\n```python\nimport numpy as np\n\n# mathematical constants\nprint(np.pi)\nprint(np.e)\n\n# trignometric functions\nangle = np.pi/4\nprint(np.sin(angle))\nprint(np.cos(angle))\nprint(np.tan(angle))\n```\n\n 3.141592653589793\n 2.718281828459045\n 0.707106781187\n 0.707106781187\n 1.0\n\n\n### Working with Lists\n\nLists are a versatile way of organizing your data in Python. Here are some examples, more can be found on [this Khan Academy video](http://youtu.be/zEyEC34MY1A).\n\n\n```python\nxList = [1, 2, 3, 4]\nxList\n```\n\n\n\n\n [1, 2, 3, 4]\n\n\n\nConcatentation is the operation of joining one list to another. \n\n\n```python\n# Concatenation\nx = [1, 2, 3, 4];\ny = [5, 6, 7, 8];\n\nx + y\n```\n\n\n\n\n [1, 2, 3, 4, 5, 6, 7, 8]\n\n\n\nSum a list of numbers\n\n\n```python\nnp.sum(x)\n```\n\n\n\n\n 10\n\n\n\nAn element-by-element operation between two lists may be performed with \n\n\n```python\nprint(np.add(x,y))\nprint(np.dot(x,y))\n```\n\n [ 6 8 10 12]\n 70\n\n\nA for loop is a means for iterating over the elements of a list. The colon marks the start of code that will be executed for each element of a list. Indenting has meaning in Python. In this case, everything in the indented block will be executed on each iteration of the for loop. This example also demonstrates string formatting.\n\n\n```python\nfor x in xList:\n print(\"sin({0}) = {1:8.5f}\".format(x,np.sin(x)))\n```\n\n sin(1) = 0.84147\n sin(2) = 0.90930\n sin(3) = 0.14112\n sin(4) = -0.75680\n\n\n### Working with Dictionaries\n\nDictionaries are useful for storing and retrieving data as key-value pairs. For example, here is a short dictionary of molar masses. The keys are molecular formulas, and the values are the corresponding molar masses.\n\n\n```python\nmw = {'CH4': 16.04, 'H2O': 18.02, 'O2':32.00, 'CO2': 44.01}\nmw\n```\n\n\n\n\n {'CH4': 16.04, 'CO2': 44.01, 'H2O': 18.02, 'O2': 32.0}\n\n\n\nWe can a value to an existing dictionary.\n\n\n```python\nmw['C8H18'] = 114.23\nmw\n```\n\n\n\n\n {'C8H18': 114.23, 'CH4': 16.04, 'CO2': 44.01, 'H2O': 18.02, 'O2': 32.0}\n\n\n\nWe can retrieve a value from a dictionary.\n\n\n```python\nmw['CH4']\n```\n\n\n\n\n 16.04\n\n\n\nA for loop is a useful means of interating over all key-value pairs of a dictionary.\n\n\n```python\nfor species in mw.keys():\n print(\"The molar mass of {: \n", "meta": {"hexsha": "4fc38c854550b6e4eb4761121718694800573ac9", "size": 139296, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/Mathematical Modeling/01.01-Getting-Started-with-Python-and-Jupyter-Notebooks.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/Mathematical Modeling/01.01-Getting-Started-with-Python-and-Jupyter-Notebooks.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/Mathematical Modeling/01.01-Getting-Started-with-Python-and-Jupyter-Notebooks.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": 166.2243436754, "max_line_length": 30874, "alphanum_fraction": 0.8902911785, "converted": true, "num_tokens": 3884, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.32082131381216084, "lm_q2_score": 0.26284183159693775, "lm_q1q2_score": 0.0843252617377243}}
{"text": "## GeostatsPy: Univariate Spatial Trend Modeling for Subsurface Data Analytics in Python \n\n\n### Michael Pyrcz, Associate Professor, University of Texas at Austin \n\n#### [Twitter](https://twitter.com/geostatsguy) | [GitHub](https://github.com/GeostatsGuy) | [Website](http://michaelpyrcz.com) | [GoogleScholar](https://scholar.google.com/citations?user=QVZ20eQAAAAJ&hl=en&oi=ao) | [Book](https://www.amazon.com/Geostatistical-Reservoir-Modeling-Michael-Pyrcz/dp/0199731446) | [YouTube](https://www.youtube.com/channel/UCLqEr-xV-ceHdXXXrTId5ig) | [LinkedIn](https://www.linkedin.com/in/michael-pyrcz-61a648a1)\n\n\n### PGE 383 Exercise: Univariate Spatial Trends Modeling for Subsurface Data Analytics in Python \n\nHere's a simple workflow with basic univariate spatial trend modeling for subsurface modeling workflows. This should help you get started with building subsurface models that include deterministic and stochastic components. \n\n#### Trend Modeling\n\nTrend modeling is the modeling of local features, based on data and interpretation, that are deemed certain (known). The trend is substracted from the data, leaving a residual that is modeled stochastically with uncertainty (treated as unknown).\n\n* geostatistical spatial estimation methods will make an assumption concerning stationarity\n * in the presence of significant nonstationarity we can not rely on spatial estimates based on data + spatial continuity model\n* if we observe a trend, we should model the trend.\n * then model the residuals stochastically\n\nSteps: \n\n1. model trend consistent with data and intepretation at all locations within the area of itnerest, integrate all available information and expertise.\n\n\\begin{equation}\nm(\\bf{u}_\\beta), \\, \\forall \\, \\beta \\in \\, AOI\n\\end{equation}\n\n2. substract trend from data at the $n$ data locations to formulate a residual at the data locations.\n\n\\begin{equation}\ny(\\bf{u}_{\\alpha}) = z(\\bf{u}_{\\alpha}) - m(\\bf{u}_{\\alpha}), \\, \\forall \\, \\alpha = 1, \\ldots, n\n\\end{equation}\n\n3. characterize the statistical behavoir of the residual $y(\\bf{u}_{\\alpha})$ integrating any information sources and interpretations. For example the global cumulative distribution function and a measure of spatial continuity shown here.\n\n\\begin{equation}\nF_y(y) \\quad \\gamma_y(\\bf{h})\n\\end{equation}\n\n4. model the residual at all locations with $L$ multiple realizations.\n\n\\begin{equation}\nY^\\ell(\\bf{u}_\\beta), \\, \\forall \\, \\beta \\, \\in \\, AOI; \\, \\ell = 1, \\ldots, L\n\\end{equation}\n\n5. add the trend back in to the stochastic residual realizations to calculate the multiple realizations, $L$, of the property of interest based on the composite model of known deterministic trend, $m(\\bf{u}_\\alpha)$ and unknown stochastic residual, $y(\\bf{u}_\\alpha)$ \n\n\\begin{equation}\nZ^\\ell(\\bf{u}_\\beta) = Y^\\ell(\\bf{u}_\\beta) + m(\\bf{u}_\\beta), \\, \\forall \\, \\beta \\in \\, AOI; \\, \\ell = 1, \\ldots, L\n\\end{equation}\n\n6. check the model, including quantification of the proportion of variance treated as known (trend) and unknown (residual).\n\n\\begin{equation}\n\\sigma^2_{Z} = \\sigma^2_{Y} + \\sigma^2_{m} + 2 \\cdot C_{Y,m}\n\\end{equation}\n\ngiven $C_{Y,m} \\to 0$:\n\n\\begin{equation}\n\\sigma^2_{Z} = \\sigma^2_{Y} + \\sigma^2_{m}\n\\end{equation}\n\nI can now describe the proportion of variance allocated to known and unknown components as follows:\n\n\\begin{equation}\nProp_{Known} = \\frac{\\sigma^2_{m}}{\\sigma^2_{Y} + \\sigma^2_{m}} \\quad Prop_{Unknown} = \\frac{\\sigma^2_{Y}}{\\sigma^2_{Y} + \\sigma^2_{m}}\n\\end{equation}\n\nI provide some practical, data-driven methods for trend model, but I should indicate that:\n\n1. trend modeling is very important in reservoir modeling as it has large impact on local model accuracy and on the undertainty model\n2. trend modeling is used in almost every subsurface model, unless the data is dense enough to impose local trends\n3. trend modeling includes a high degree of expert judgement combined with the integration of various information sources\n\nWe limit ourselves to simple data-driven methods, but acknowledge much more is needed. In fact, trend modeling requires a high degree of knowledge concerning local geoscience and engineering data and knowledge. \n\n#### Objective \n\nIn the PGE 383: Stochastic Subsurface Modeling class I want to provide hands-on experience with building subsurface modeling workflows. Python provides an excellent vehicle to accomplish this. I have coded a package called GeostatsPy with GSLIB: Geostatistical Library (Deutsch and Journel, 1998) functionality that provides basic building blocks for building subsurface modeling workflows. \n\nThe objective is to remove the hurdles of subsurface modeling workflow construction by providing building blocks and sufficient examples. This is not a coding class per se, but we need the ability to 'script' workflows working with numerical methods. \n\n#### Getting Started\n\nHere's the steps to get setup in Python with the GeostatsPy package:\n\n1. Install Anaconda 3 on your machine (https://www.anaconda.com/download/). \n2. From Anaconda Navigator (within Anaconda3 group), go to the environment tab, click on base (root) green arrow and open a terminal. \n3. In the terminal type: pip install geostatspy. \n4. Open Jupyter and in the top block get started by copy and pasting the code block below from this Jupyter Notebook to start using the geostatspy functionality. \n\nYou will need to copy the data file to your working directory. They are available here:\n\n* Tabular data - sample_data_biased.csv at https://git.io/fh0CW\n\nThere are exampled below with these functions. You can go here to see a list of the available functions, https://git.io/fh4eX, other example workflows and source code. \n\n\n```python\nimport geostatspy.GSLIB as GSLIB # GSLIB utilies, visualization and wrapper\nimport geostatspy.geostats as geostats # GSLIB methods convert to Python \n```\n\nWe will also need some standard packages. These should have been installed with Anaconda 3.\n\n\n```python\nimport numpy as np # ndarrys for gridded data\nimport pandas as pd # DataFrames for tabular data\nimport os # set working directory, run executables\nimport matplotlib.pyplot as plt # for plotting\nfrom scipy import stats # summary statistics\nimport math # trig etc.\nimport scipy.signal as signal # kernel for moving window calculation\n```\n\n#### Set the working directory\n\nI always like to do this so I don't lose files and to simplify subsequent read and writes (avoid including the full address each time). \n\n\n```python\nos.chdir(\"c:/PGE383\") # set the working directory\n```\n\n#### Loading Tabular Data\n\nHere's the command to load our comma delimited data file in to a Pandas' DataFrame object. \n\n\n```python\ndf = pd.read_csv('sample_data_biased.csv') # load our data table (wrong name!)\n```\n\nIt worked, we loaded our file into our DataFrame called 'df'. But how do you really know that it worked? Visualizing the DataFrame would be useful and we already leard about these methods in this demo (https://git.io/fNgRW). \n\nWe can preview the DataFrame by printing a slice or by utilizing the 'head' DataFrame member function (with a nice and clean format, see below). With the slice we could look at any subset of the data table and with the head command, add parameter 'n=13' to see the first 13 rows of the dataset. \n\n\n```python\nprint(df.iloc[0:5,:]) # display first 4 samples in the table as a preview\ndf.head(n=13) # we could also use this command for a table preview\n```\n\n X Y Facies Porosity Perm\n 0 100 900 1 0.115359 5.736104\n 1 100 800 1 0.136425 17.211462\n 2 100 600 1 0.135810 43.724752\n 3 100 500 0 0.094414 1.609942\n 4 100 100 0 0.113049 10.886001\n\n\n\n\n\n Diagrams which enter the definition of the ground-state shift energy $\\Delta E_0$. Diagram (i) is first order in the interaction $\\hat{v}$, while diagrams (ii) and (iii) are examples of contributions to second and third order, respectively. The evolution of the posterior pdf for the bias-weighting of a coin, as the number of data available increases. The figure on the top left-hand corner of each panel shows the number of data included in the analysis. Single photon counts (flux measurements). Bayesian posterior pdf (represented by a histogram of MCMC samples) from flux measurements. 5 rows × 51 columns 8 rows × 256 columns 1 rows × 27 columns 80618 rows × 12 columns Expected experimental information on the calcium isotopes that can be obtained at FRIB. The limits for detailed spectroscopic information are around $A\\sim 60$. Artist's rendition of the emission of one proton from various oxygen isotopes. Single-particle spectrum and quantum numbers for a harmonic oscillator potential and a Woods-Saxon potential with and without a spin-orbit force. Schematic plot of the possible single-particle levels with double degeneracy. The filled circles indicate occupied particle states. The spacing between each level $p$ is constant in this picture. We show some possible two-particle states. Now let's see what is this thing called paragraph. Hmmm looks interesting. Actually I can put new lines and new paragraphs. Let's see how we can put image to our first try with Markdown. Now let's try some text formats in a paragraph. And some code format: And some code inline format: Let's see what is a link - Software University Sample table example: or $Ax = b$. In this form, a solution to the system is the vector $x$ that satisfies the equation. is $\\det(A) = ad - bc$. We can break this formula down and generalize it to larger matrices. since the the minors $A_{0i}, i = 0, 1$ are scalars so are equal to their determinants by our definition above. Even better, we can take care of the minus sign by noting that or $Ly = c$. The matrix $L$ is lower triangular, which means all the elements above its diagonal are zero. which only depends on the previous values of $y\\,$: $y_{i-1}, y_{i-2}, \\ldots, y_0$. or $Uy = c$. Here we would simply move up the rows, substituting and solving for one new variable each time; a process called, unsurprisingly, backwards substitution. giving us where $y \\equiv Ux$. We can easily solve for $y$ using forward substitution. Having done that, we have and we can now solve for $x$ by forward substituion. Generator: BufferStockTheory-make/notebooks_byname For the following badges: GitHub does not allow click-through redirects; right-click to get the link, then paste into navigation bar \n \n \n \n Un saco se desliza por la rampa, como se ve en la figura, con una velocidad horizontal de $12 m/s$. Si la altura de la rampa es de $6 m$, determine el tiempo necesario para que el saco choque con el suelo y la distancia $R$ donde los sacos comienzan a apilarse \n \n \n \n \n \n \n \n \n \n \n \n \n \n Cuando el esquiador llega al punto $A$ a lo largo de la trayectoria parabólica en la figura, su rapidez es de $6 m/s$, la cual se incrementa a $2 m/s^2$. Determine la dirección de su velocidad y la dirección y magnitud de su aceleración en este instante. Al hacer el cálculo, pase por alto la estatura del esquiador.. \n \n \n \n \n \n \n \n \n \n \n \n Debido a la rotación de la barra ahorquillada, la bola en la figura se mueve alrededor de una trayectoria ranurada, una parte de la cual tiene la forma de un cardioide, $r=0.5(1 - cos(\\theta)) pies$, donde $\\theta$ está en radianes. Si la velocidad de la bola es $v=4 pies/s$ y su aceleración es $a=30 pies/s^2$ en el instante $\\theta=180^{\\circ}$, determine la velocidad angular $\\dot{theta}$ y la aceleración angular $\\ddot{\\theta}$ de la horquilla. Maximum likelihood estimate vs. true parameter. Note that the estimate is slightly off from the true value. This is a consequence of the fact that the estimator is a function of the data and lacks knowledge of the true underlying value. Histogram of maximum likelihood estimates. The title shows the estimated mean and standard deviation of the samples. Probability mass function for $\\hat{p}$. The two vertical lines form the confidence interval. The odds ratio is close to linear for small values but becomes unbounded as $p$ approaches one. The delta method is more effective for small underlying values of $p$, where the linear approximation is better. Iterate over the elements of a sequence (such as a string, tuple, list or array) or other iterable object Take Note Note the double colon (`:`) at the end of the `for` statement and the indentation infront of the body. This tells *Python* where the header ends and which program statements (lines of code) belong to the body that will be repeated.\n More Information You can get more information about the `for` statement by executing `help(\"for\")` in a *Code Cell* Take Note Be very careful and aware of indentation when typing your programs, as this can sometimes lead to unexpected results and logic errors. There is a big difference between the following two examples. Make sure you know the difference in the results of these two examples and why they are different !!! More Information Most editors (like *Jupyter Notebook*) will automatically add 4 spaces when you push the `tab` key. And `Shift + tab` will automatically remove 4 spaces. This can also be used if you have highlighted several lines of code. Try it !! More Information Remember that you can use the `numpy.math.factorial(N)` function to verify the result of this example. Take Note Notice the indentation for this nested loop example above. Lines 5 to 9 require 4 spaces in front of the program statements to \"tell\" *Python* that they are inside the first (outer) `for` loop. Lines 7 and 8 require 4+4 spaces in front of the program statements to \"tell\" *Python* that they are inside the second (inner) `for` loop. Make sure you understand the behaviour and output of the following three examples and why they are different!! 5 rows × 28 columns Sánchez, Juan Pablo (jpsanchez@fi.uba.ar) - 105.865 de Luca Andrea, Felipe (fdeluca@fi.uba.ar) - 105.646 Litteri, Iván (ilitteri@fi.uba.ar - 106.223 Sassano 26 de mayo del 2021 Python Ayudamos a un familiar a la hora de ajustar el volumen del celular para poder ver una película. Decidimos emplear el método de bisección para hallar el volumen adecuado. El método consiste en obtener, mediante un intervalo ($\\tau$), una raíz definida como cero en el método. Para ello, necesitamos conocer si existe un cambio de signo en el mismo, de lo contrario no podemos garantizar la existencia de la raíz buscada. En caso de no encontrarla, se divide el intervalo en dos y se vuelve a evaluar el cambio de signo antedicho. El proceso debe repetirse hasta mejorar la aproximación, de acuerdo con el error que estemos dispuestos a aceptar. \n \n Fig.1 En naranja y amarillo se ve el máximo y mínimo del diálogo. La segunda vez que preguntamos vemos el volumen en verde, en magenta el valor requerido por el usuario. Con lo cual, por lo dicho en ($\\rho$) debemos obtener un valor que no necesariamente se encuentre en el medio, ya que dependerá de la subjetividad del usuario en cuestión, pero que por el Teorema del Valor Intermedio sabemos que debe existir dentro del intervalo que poseemos. Vemos entonces la definición del intervalo que buscábamos ($\\tau$) para aplicar el método que necesitamos. Como quedan dos intervalos (el primero, y el definido en el diálogo, lógicamente comprendido en el anterior) chequeamos cada uno por separado. Por ende, subimos y/o bajamos el volumen del teléfono y volvemos a preguntar. Respecto al error, el mismo queda limitado por la cantidad de divisiones que posea la escala de volúmenes en el teléfono, con lo cual no podremos controlar ese aspecto. Se nos ocurrió esta idea ya que hace unos meses uno de los integrantes del grupo estaba ayudando a su abuela a usar su teléfono, siendo que ella no lo sabe utilizar muy bien. En ese entonces, ella había estado recibiendo llamados pero tenía el teléfono silenciado y no se acordaba como subirle el volumen, por lo que me pidio ayuda ya que había pasado por su casa a dejarle unas cosas. La experiencia fue muy similar a lo expresado anteriormente: puse un video de youtube para poder ir testeando el sonido, lo puse a la mitad y le pregunté si estaba muy alto o muy bajo. Así una o dos veces más y se lo deje, no tuvo más inconviententes. A partir de las siguientes iteraciones la calculadora continuaba mostrando $\\pi$, siendo el error tan pequeño que esta ya no podía diferenciarlo de acuerdo a sus especificaciones. Aclaración: La serie de Leibniz converge a $\\frac{1}{4}\\pi$ y en este caso se calculó sin multiplicar el valor por 4. Por comodidad, el valor real de este número es $\\frac{1}{4}\\pi = 0.7853981634 \\pm 0.0000000001$. Se puede notar que al llegar a $100000$ iteraciones (tras 2 horas calculando), la calculadora acumuló más error del que venía con $10000$. Las siguientes iteraciones de Newton Raphson ya no variaban, por lo que el error del método ya era más pequeño que el del tipo de dato utilizado en el cálculo. Por lo tanto, el error del resultado será el del tipo de dato. Un punto flotante de 32 bits tiene reservados 23 dígitos para la mantisa, más el dígito implícito, por lo que en base 10 tendrá $log_{10}(2^{24}) \\rfloor = 7$ dígitos significativos. Por lo tanto: Nuevamente el error será el de la representación del tipo de dato. Un punto flotante de 64 bits tiene reservados 52 dígitos para la mantisa, más el dígito implícito, por lo que en base 10 tendrá $\\log_{10}(2^{53}) \\rfloor = 15$ dígitos significativos. Por lo tanto: En este caso, por las mismas razones expresadas anteriormente, el error va a ser el de la calculadora. En este caso, esta especificaba un error de $\\pm 1$ en el décimo dígito, es decir, 10 cifras significativas: Si bien la calculadora guarda el número como una constante, se debería considerar una variable a la hora de calcular el error y su propagación, ya que al ser $\\pi$ un número irracional este tiene infinitos dígitos que son imposibles de almacenar en una computadora, y mucho menos hacer cálculos con todos ellos. El error a considerar dependerá de las especificaciones del tipo de dato que se este utilizando para almacenarlo. Mientras que con las funciones $f_{1}(x)$ y $f_{2}(x)$ no hubo ningún problema al utilizar el algoritmo de Newton Raphson, la función $ f_{3}(x) = (x-1.5) \\cdot e^{-4 \\cdot (x-1.5)^{2}} $ da error. Esto se debe a que una derivada de las que el algoritmo evaluó al calcular la siguiente iteración dio nula, lo que fue resultado de que la sucesión diverja. En este caso, esto sucede ya que la semilla no esta lo suficientemente próxima a la raíz (se utiliza raiz = 1 como fue indicado). El método de Newton Raphson se basa en utilizar la iteración por punto fijo de la función $ g(x) = x - \\frac{f(x)}{f'(x)} $, ya que si $ g(r) = r $ entonces $\\frac{f(r)}{f'(r)} = 0$ por lo que tenemos una raíz de $ f $ ($f'(r) \\neq 0$). La raíz de esta función se encuentra en $ r = 1,5 $, y una de las hipótesis utilizadas en la demostración de la convergencia de la iteración de punto fijo\nes que para $ \\forall x \\in [a, b]$, $|g'(x)| < 1$ (unicidad del punto fijo), \ndonde $[a, b]$ es el intervalo dentro del cual estamos iterando. En este caso, $g'(x) = 1 - \\frac{f'(x)^2 - f(x)f''(x)}{f'(x)^2} = \\frac{f(x)f''(x)}{f'(x)^2}$ pero $g'(1) = -2$, por lo que incluir $ x = 1 $ en este intervalo implica que el método puede no converger. Otra forma de verlo es notar que la expresión de Newton-Rhapson se puede deducir a partir del polinomio de Taylor de $f(x)$ alrededor de un $x_{n}$. En tal caso, $f(x) = f(x_{n}) + f'(x_{n})(x - x_{n}) + \\frac{f''(\\xi)}{2}(x - x_{n})^2$, con $\\xi$ entre $x$ y $x_{n}$. Entonces, si evaluamos la función en la raíz $r$ de $f(x)$ queda $0 = f(r) = f(x_{n}) + f'(x_{n})(r - x_{n}) + \\frac{f''(\\xi)}{2}(r - x_{n})^2$. El método de Newton-Raphson asume que $x_n$ esta lo suficientemente cerca de $r$ tal que $(r-x_n)^2 << (r-x_n)$ lo que nos permite despreciar el último término del polinomio y asi obtener la expresión $r \\approx x_n - \\frac{f(x_n)}{f'(x_n)} \\Rightarrow x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$. En este caso, la semilla no es lo suficientemente cercana como para que esto se cumpla. Para poder hacere que converja, podemos acercar la semilla un poco (a 1,3): En este caso, la función 2 convergió mucho más rápido que con Newton-Raphson ya que es una función cuya raíz tenía multiplicidad mayor a uno, por lo que con este método conservamos la convergencia cuadrática. En cuanto a la función 3, nuevamente falló al calcular alguna de las iteraciones debido a que el divisor se hizo 0. Esto se debe a que la función no convergió a la raíz por las mismas razones que Newton-Raphson, y podemos solucionarlo acercando la semilla: Se puede notar como a este método le toman mas iteraciones converger que para otro método como Newton-Raphson, ya que al estar basado en este pero utilizar la secante como aproximación de la derivada de una función es normal que tarde más. Nuevamente, este método falla con la tercera función. Al estar este basado en Newton-Raphson, también puede fallar si las semillas se encuentran muy alejadas de la raíz. Por lo tanto, podemos acercársela un poco para que converja: El orden de convergencia de la bisección dio exactamente igual a lo esperado. Siempre va a ser 1 ya que se trata de un método que iteración por iteración va reduciendo el error a la mitad linealmente, por lo que nunca va a variar. En el caso de la primera y última función, estuvo bastante cerca del valor esperado de 2 (o incluso superior) durante la mayor parte de las iteraciones. En cuanto a la segunda función, se sostuvo más que nada alrededor de 1, que también era de esperar al ser una función con raíz doble con lo cual este método no mantiene la convergencia cuadrática. Para la primera y última función, nuevamente el orden estuvo alrededor de 2 como se esperaba. Aún así, en la segunda función esperabamos un orden de convergencia más cercano a 2 ya que se supone que este método mantiene convergencia cuadrática incluso cuando la raíz es múltiple. Es posible que esto se deba a la poca cantidad de iteraciones realizadas. La primera función tuvo un orden promediando entre 1 y 2, como es esperado, ya que debe ser mayor a 1 pero menor a 2 al aproximar la derivada con una recta secante. Para la segunda función, se mantuvo principalmente en 1 una vez más debido a la raíz múltiple de esta. Para la tercera, el orden oscilo en valores alrededor de 2, lo cual es un poco superior a lo esperado pero sigue estando dentro de un rango esperado. En este caso, la constante asintótica es la esperada ya que como el orden de convergencia es 1, esto significa que $\\varepsilon_n = 0,5 \\cdot \\varepsilon_{n-1}$, lo cual es exactamente lo que hace el método: va dividiendo a la mitad el intervalo de búsqueda, por lo que el error lo hace también. En cuanto a los otros métodos, la mayoría de las iteraciones lograron una constante asintótica entre 0 y 1, que es lo esperado, ya que implica que el error esta en efecto bajando con el orden de convergencia calculado. Forzamos la escala del eje y entre 0 y 1 para que se pueda apreciar esto, ya que había ciertas iteraciones con picos muy pronunciados que hacían que la escala se agrande mucho y parezca que la constante valía 0 en la mayoría de las iteraciones. Esto provocó que los gráficos de Newton-Raphson y Newton-Raphson modificado queden vacíos para la tercera función, ya que estaban dando valores por fuera de este rango. En aquellas iteraciones que se van de rango y en caso de las iteraciones con picos muy pronunciados, es bastante probable que se deban a la poca cantidad de iteraciones que se necesitaron para alcanzar el error buscado, lo que hace que las aproximaciones realizadas para el cálculo de la constante asintótica, que incluso arrastra también el error del orden de convergencia, no sean tan buenas. Calcular el valor real implicaría un limite con iteraciones tendiendo a infinito. 5 rows × 26 columns Name Date Diaaeldin SHALABY Setting up notebook ... finished. All exercises in this assignment are referring to the FrozenLake-v0 environment of OpenAI Gym. This environment is descibed according to its official OpenAI Gym website as follows:\n\n \n
\n\n \n \n \n \n X \n Y \n Facies \n Porosity \n Perm \n \n \n 0 \n 100 \n 900 \n 1 \n 0.115359 \n 5.736104 \n \n \n 1 \n 100 \n 800 \n 1 \n 0.136425 \n 17.211462 \n \n \n 2 \n 100 \n 600 \n 1 \n 0.135810 \n 43.724752 \n \n \n 3 \n 100 \n 500 \n 0 \n 0.094414 \n 1.609942 \n \n \n 4 \n 100 \n 100 \n 0 \n 0.113049 \n 10.886001 \n \n \n 5 \n 200 \n 800 \n 1 \n 0.154648 \n 106.491795 \n \n \n 6 \n 200 \n 700 \n 1 \n 0.153113 \n 140.976324 \n \n \n 7 \n 200 \n 500 \n 1 \n 0.126167 \n 12.548074 \n \n \n 8 \n 200 \n 400 \n 0 \n 0.094750 \n 1.208561 \n \n \n 9 \n 200 \n 100 \n 1 \n 0.150961 \n 44.687430 \n \n \n 10 \n 300 \n 800 \n 1 \n 0.199227 \n 1079.709291 \n \n \n 11 \n 300 \n 700 \n 1 \n 0.154220 \n 179.491695 \n \n \n \n12 \n 300 \n 500 \n 1 \n 0.137502 \n 38.164911 \n \n \n
\n\n \n \n \n \n count \n mean \n std \n min \n 25% \n 50% \n 75% \n max \n \n \n X \n 289.0 \n 475.813149 \n 254.277530 \n 0.000000 \n 300.000000 \n 430.000000 \n 670.000000 \n 990.000000 \n \n \n Y \n 289.0 \n 529.692042 \n 300.895374 \n 9.000000 \n 269.000000 \n 549.000000 \n 819.000000 \n 999.000000 \n \n \n Facies \n 289.0 \n 0.813149 \n 0.390468 \n 0.000000 \n 1.000000 \n 1.000000 \n 1.000000 \n 1.000000 \n \n \n Porosity \n 289.0 \n 0.134744 \n 0.037745 \n 0.058548 \n 0.106318 \n 0.126167 \n 0.154220 \n 0.228790 \n \n \n \nPerm \n 289.0 \n 207.832368 \n 559.359350 \n 0.075819 \n 3.634086 \n 14.908970 \n 71.454424 \n 5308.842566 \n \n \n
\n\n \n \n \n \n X \n Y \n Facies \n Porosity \n Perm \n Wts \n \n \n 0 \n 100 \n 900 \n 1 \n 0.115359 \n 5.736104 \n 3.064286 \n \n \n 1 \n 100 \n 800 \n 1 \n 0.136425 \n 17.211462 \n 1.076608 \n \n \n 2 \n 100 \n 600 \n 1 \n 0.135810 \n 43.724752 \n 0.997239 \n \n \n 3 \n 100 \n 500 \n 0 \n 0.094414 \n 1.609942 \n 1.165119 \n \n \n \n4 \n 100 \n 100 \n 0 \n 0.113049 \n 10.886001 \n 1.224164 \n \n \n
\n\n \n \n \n \n X \n Y \n Facies \n Porosity \n Perm \n Wts \n Por_Trend \n Por_Res \n \n \n 0 \n 100 \n 900 \n 1 \n 0.115359 \n 5.736104 \n 3.064286 \n 0.117365 \n -0.002006 \n \n \n 1 \n 100 \n 800 \n 1 \n 0.136425 \n 17.211462 \n 1.076608 \n 0.123938 \n 0.012487 \n \n \n 2 \n 100 \n 600 \n 1 \n 0.135810 \n 43.724752 \n 0.997239 \n 0.128435 \n 0.007375 \n \n \n 3 \n 100 \n 500 \n 0 \n 0.094414 \n 1.609942 \n 1.165119 \n 0.112399 \n -0.017985 \n \n \n \n4 \n 100 \n 100 \n 0 \n 0.113049 \n 10.886001 \n 1.224164 \n 0.102791 \n 0.010258 \n \n\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_{x}^{2}+n_{y}^{2}$ $n_{x}$ $n_{y}$ $N_{\\uparrow \\downarrow }$ $N_{\\uparrow \\uparrow }$ 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
\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\n\n\n\n\n\n\n## Exercise 4: Quantum numbers for the electron gas in 3d\n\n\n**a)**\nSet up the quantum numbers for the electron gas in 3d using a given value \nof $n_{\\mathrm{max}}$.\n\n\n\n**Solution.**\nThe following python code sets up the quantum numbers for both infinite nuclear matter and neutron matter meploying a cutoff in the value of $n$.\n\n\n```\nfrom numpy import *\n\nnmax =1\nnshell = 3*nmax*nmax\ncount = 1\ntzmin = 1\nprint (\"------------------------------------\")\nprint (\"Neutron matter or the electron gas:\") \nprint (\"a, nx, ny, nz, sz, nx^2 + ny^2 + nz^2\")\nfor n in range(nshell): \n for nx in range(-nmax,nmax+1):\n for ny in range(-nmax,nmax+1):\n for nz in range(-nmax, nmax+1): \n for sz in range(-1,1+1):\n e = nx*nx + ny*ny + nz*nz\n if e == n:\n if sz != 0: \n print count, \" \",nx,\" \",ny, \" \",sz,\" \",tz,\" \",e\n count += 1\n```\n\n\n\n\n\n\n**b)**\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```\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 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 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\n\n\n\n\n## Infinite nuclear matter and neutron star matter\n\nStudies of dense baryonic matter are of central importance to our basic understanding \nof the stability of nuclear matter, spanning from matter at high densities and temperatures\nto matter as found within dense astronomical objects like neutron stars. \n\nNeutron star matter\nat densities of 0.1 fm$^{-3}$ and greater, is often assumed to \nbe made of mainly neutrons, protons, electrons and \nmuons in beta equilibrium. However, other baryons like various hyperons may exist, as well as possible mesonic condensates and transitions to quark degrees of freedom at higher densities. \nHere we focus on specific definitions of various phases and focus \non distinct phases of matter such as pure baryonic\nmatter and/or quark matter.\nThe composition of matter is then \ndetermined by the requirements of chemical and electrical equilibrium.\nFurthermore, we will also consider matter at temperatures much lower\nthan the typical Fermi energies.\nThe equilibrium conditions are governed by the weak processes \n(normally referred to as the processes\nfor $\\beta$-equilibrium)\n\n\n\n\n$$\n\\begin{equation} \n b_1 \\rightarrow b_2 + l +\\bar{\\nu}_l \\hspace{1cm} b_2 +l \\rightarrow b_1 \n+\\nu_l,\n\\label{eq:betadecay} \\tag{25}\n\\end{equation}\n$$\n\nwhere $b_1$ and $b_2$ refer to e.g.\\ the baryons being a neutron and a proton, \nrespectively, \n$l$ is either an electron or a muon and $\\bar{\\nu}_l $\nand $\\nu_l$ their respective anti-neutrinos and neutrinos. Muons typically \nappear at\na density close to nuclear matter saturation density, the latter being\n\n$$\nn_0 \\approx 0.16 \\pm 0.02 \\hspace{1cm} \\mathrm{fm}^{-3},\n$$\n\nwith a corresponding binding energy ${\\cal E}_0$ \nfor symmetric nuclear matter (SNM) at saturation density of\n\n$$\n{\\cal E}_0 = B/A=-15.6\\pm 0.2 \\hspace{1cm} \\mathrm{MeV}.\n$$\n\nIn this work the energy per baryon ${\\cal E}$ will always be in units of MeV, \nwhile\nthe energy density $\\varepsilon$ will \nbe in units of MeVfm$^{-3}$ and the number density\\footnote{We will often \nloosely just use density in our discussions.}\n$n$ in units of fm$^{-3}$. The pressure $P$ is \ndefined through the relation\n\n\n\n\n$$\n\\begin{equation}\n P=n^2\\frac{\\partial {\\cal E}}{\\partial n}=\n n\\frac{\\partial \\varepsilon}{\\partial n}-\\varepsilon,\n\\label{_auto19} \\tag{26}\n\\end{equation}\n$$\n\nwith \ndimension MeVfm$^{-3}$. \nSimilarly, the chemical potential for particle species $i$\nis given by\n\n\n\n\n$$\n\\begin{equation}\n \\mu_i = \\left(\\frac{\\partial \\varepsilon}{\\partial n_i}\\right),\n\\label{eq:chemicalpotdef} \\tag{27}\n\\end{equation}\n$$\n\nwith dimension MeV.\nIn calculations of properties of neutron star matter in $\\beta$-equilibrium,\nwe will need to calculate the energy per baryon ${\\cal E}$ for e.g. several \nproton fractions $x_p$, which corresponds to\nthe ratio of protons as\ncompared to the total nucleon number ($Z/A$), \n defined as\n\n\n\n\n$$\n\\begin{equation}\n x_p = \\frac{n_p}{n},\n\\label{_auto20} \\tag{28}\n\\end{equation}\n$$\n\nwhere $n=n_p+n_n$, the total baryonic density if neutrons and\nprotons are the only baryons present. In that case,\nthe total Fermi momentum $k_F$ and the Fermi momenta $k_{Fp}$,\n$k_{Fn}$ for protons and neutrons are related to the total nucleon density\n$n$ by\n\n$$\nn = \\frac{2}{3\\pi^2} k_F^3 \\nonumber\n$$\n\n$$\n= x_p n + (1-x_p) n \\nonumber\n$$\n\n\n\n\n$$\n\\begin{equation} \n = \\frac{1}{3\\pi^2} k_{Fp}^3 + \\frac{1}{3\\pi^2} k_{Fn}^3.\n\\label{eq:densi} \\tag{29}\n\\end{equation}\n$$\n\nThe energy per baryon will thus be\nlabelled as ${\\cal E}(n,x_p)$.\n${\\cal E}(n,0)$ will then refer to the energy per baryon for pure neutron\nmatter (PNM) while ${\\cal E}(n,\\frac{1}{2})$ is the corresponding value for \nSNM. Furthermore, in this work, subscripts $n,p,e,\\mu$\nwill always refer to neutrons, protons, electrons and muons, respectively.\n\n\nSince the mean free path of a neutrino in a neutron star is bigger\nthan the typical radius of such a star ($\\sim 10$ km), \nwe will throughout assume that neutrinos escape freely from the neutron star,\nsee for example the work of Prakash et al.\nfor a discussion\non trapped neutrinos. Eq. ([eq:betadecay](#eq:betadecay)) yields then the following\nconditions for matter in $\\beta$ equilibrium with for example nucleonic degrees \nfreedom only\n\n\n\n\n$$\n\\begin{equation}\n \\mu_n=\\mu_p+\\mu_e,\n\\label{eq:npebetaequilibrium} \\tag{30}\n\\end{equation}\n$$\n\nand\n\n\n\n\n$$\n\\begin{equation}\n n_p = n_e,\n\\label{eq:chargeconserv} \\tag{31}\n\\end{equation}\n$$\n\nwhere $\\mu_i$ and $n_i$ refer to the chemical potential and number density\nin fm$^{-3}$ of particle species $i$. \nIf muons are present as well, we need to modify the equation for \ncharge conservation, Eq. ([eq:chargeconserv](#eq:chargeconserv)), to read\n\n$$\nn_p = n_e+n_{\\mu},\n$$\n\nand require that $\\mu_e = \\mu_{\\mu}$.\nWith more particles present, the equations read\n\n\n\n\n$$\n\\begin{equation}\n \\sum_i\\left(n_{b_i}^+ +n_{l_i}^+\\right) = \n \\sum_i\\left(n_{b_i}^- +n_{l_i}^-\\right),\n\\label{eq:generalcharge} \\tag{32}\n\\end{equation}\n$$\n\nand\n\n\n\n\n$$\n\\begin{equation} \n \\mu_n=b_i\\mu_i+q_i\\mu_l,\n\\label{eq:generalbeta} \\tag{33}\n\\end{equation}\n$$\n\nwhere $b_i$ is the baryon number, $q_i$ the lepton charge and the superscripts \n$(\\pm)$ on \nnumber densities $n$ represent particles with positive or negative charge.\nTo give an example, it is possible to have baryonic matter with hyperons like\n$\\Lambda$ \nand $\\Sigma^{-,0,+}$ and isobars $\\Delta^{-,0,+,++}$ as well in addition\nto the nucleonic degrees of freedom.\nIn this case the chemical equilibrium condition of Eq. ([eq:generalbeta](#eq:generalbeta)) \nbecomes,\nexcluding muons,\n\n$$\n\\mu_{\\Sigma^-} = \\mu_{\\Delta^-} = \\mu_n + \\mu_e , \\nonumber\n$$\n\n$$\n\\mu_{\\Lambda} = \\mu_{\\Sigma^0} = \\mu_{\\Delta^0} = \\mu_n , \\nonumber\n$$\n\n$$\n\\mu_{\\Sigma^+} = \\mu_{\\Delta^+} = \\mu_p = \\mu_n - \\mu_e ,\\nonumber\n$$\n\n\n\n\n$$\n\\begin{equation} \n \\mu_{\\Delta^{++}} = \\mu_n - 2 \\mu_e .\n\\label{eq:beta_baryonicmatter} \\tag{34}\n\\end{equation}\n$$\n\nA transition from hadronic to quark matter is expected at high densities. \nThe high-density quark matter phase\nin the interior of neutron stars is also described by\nrequiring the system to be locally neutral\n\n\n\n\n$$\n\\begin{equation} \n\\label{eq:quarkneut} \\tag{35}\n (2/3)n_u -(1/3)n_d - (1/3)n_s - n_e = 0,\n\\end{equation}\n$$\n\nwhere $n_{u,d,s,e}$ \nare the densities of the $u$, $d$ and $s$ quarks and of the\nelectrons (eventually muons as well), respectively. \nMorover, the system must be in $\\beta$-equilibrium, i.e.\\ \nthe chemical potentials have to satisfy the following equations:\n\n\n\n\n$$\n\\begin{equation}\n\\label{eq:ud} \\tag{36}\n \\mu_d=\\mu_u+\\mu_e,\n\\end{equation}\n$$\n\nand\n\n\n\n\n$$\n\\begin{equation}\n\\label{eq:us} \\tag{37}\n \\mu_s=\\mu_u+\\mu_e .\n\\end{equation}\n$$\n\nEquations ([eq:quarkneut](#eq:quarkneut))-([eq:us](#eq:us)) have to be solved \nself-consistently together with the field equations for quarks \nat a fixed density $n=n_u+n_d+n_s$.\n\nAn important ingredient in the discussion of the EoS and the criteria for\nmatter in $\\beta$-equilibrium is the so-called symmetry energy ${\\cal S} (n)$, \ndefined as\nthe difference in energy for symmetric nuclear matter\nand pure neutron matter\n\n\n\n\n$$\n\\begin{equation}\n {\\cal S} (n) = {\\cal E} (n,x_p=0) - {\\cal E} (n,x_p=1/2 ).\n\\label{eq:symenergy} \\tag{38}\n\\end{equation}\n$$\n\nIf we expand the energy per baryon in the case of nucleonic degrees of freedom \nonly\nin the proton concentration $x_p$ about the value of the energy \nfor SNM ($x_p=\\frac{1}{2}$), we obtain,\n\n\n\n\n$$\n\\begin{equation}\n {\\cal E} (n,x_p)={\\cal E} (n,x_p=\\frac{1}{2})+\n \\frac{1}{2}\\frac{d^2 {\\cal E}}{dx_p^2} (n)\\left(x_p-1/2\\right)^2+\\dots ,\n\\label{eq:energyexpansion} \\tag{39}\n\\end{equation}\n$$\n\nwhere the term $d^2 {\\cal E}/dx_p^2$ \nis to be associated with the symmetry energy ${\\cal S} (n)$ in the empirical\nmass formula. If\nwe assume that higher order derivatives in the above expansion are small\n(we will see examples of this in the next subsection), then through the \nconditions\nfor $\\beta$-equilbrium of Eqs. ([eq:npebetaequilibrium](#eq:npebetaequilibrium)) and \n([eq:chargeconserv](#eq:chargeconserv))\nand Eq. ([eq:chemicalpotdef](#eq:chemicalpotdef)) we can define the proton\nfraction by the symmetry energy as\n\n\n\n\n$$\n\\begin{equation} \n \\hbar c\\left(3\\pi^2nx_p\\right)^{1/3} = 4{\\cal S} (n)\\left(1-2x_p\\right),\n\\label{eq:crudeprotonfraction} \\tag{40}\n\\end{equation}\n$$\n\nwhere the electron chemical potential is given\nby $\\mu_e = \\hbar c k_F$, i.e.\\ ultrarelativistic electrons are assumed.\nThus, the symmetry energy is of paramount importance for studies \nof neutron star matter in $\\beta$-equilibrium.\nOne can extract information about the value of the symmetry energy at saturation \ndensity\n$n_0$ from systematic studies of the masses of atomic nuclei. However, these \nresults\nare limited to densities around $n_0$ and for proton fractions close to \n$\\frac{1}{2}$.\nTypical values for ${\\cal S} (n)$ at $n_0$ are in the range $27-38$ MeV.\nFor densities greater than $n_0$ it is more difficult to get a reliable \ninformation on the symmetry energy, and thereby the related proton fraction.\nWe will shed more light on this topic in the next subsection.\n\n\nFinally, another property of interest in the discussion of the various \nequations of state \nis the incompressibility modulus $K$ at non-zero pressure\n\n\n\n\n$$\n\\begin{equation}\n K=9\\frac{\\partial P}{\\partial n}.\n\\label{eq:incompressibility} \\tag{41}\n\\end{equation}\n$$\n\nThe sound speed $v_s$ depends as well on the density\nof the nuclear medium through the relation\n\n\n\n\n$$\n\\begin{equation}\n \\left(\\frac{v_s}{c}\\right)^2=\\frac{dP}{d\\varepsilon}=\n \\frac{dP}{dn}\\frac{dn}{d\\varepsilon}=\n \\left(\\frac{K}{9(m_nc^2+{\\cal E}+P/n)}\\right).\n\\label{eq:speedofsound} \\tag{42}\n\\end{equation}\n$$\n\nIt is important to keep track of the dependence on density of $v_s$\nsince a superluminal behavior can occur at higher densities for most\nnon-relativistic EoS.\nSuperluminal behavior would\nnot occur with a fully relativistic theory, and it is necessary to\ngauge the magnitude of the effect it introduces at the higher densities.\nThis will be discussed at the end of this section.\nThe adiabatic constant $\\Gamma$ can also be extracted from the EoS\nby\n\n\n\n\n$$\n\\begin{equation}\n \\Gamma = \\frac{n}{P}\\frac{\\partial P}{\\partial n}.\n\\label{eq:adiabaticconstant} \\tag{43}\n\\end{equation}\n$$\n\n## Brueckner-Hartree-Fock theory\n\n\nThe Brueckner $G$-matrix has historically been an important ingredient\nin many-body calculations of nuclear systems. In this section, we will\nbriefly survey the philosophy behind the $G$-matrix.\n\nHistorically, the $G$-matrix was developed in microscopic nuclear\nmatter calculations using realistic nucleon-nucleon (NN) interactions.\nIt is an ingenuous as well as an interesting method to overcome the\ndifficulties caused by the strong, short-range repulsive core contained\nin all modern models for the NN interaction. The $G$-matrix method was\noriginally developed by Brueckner, and further\ndeveloped by Goldstone and Bethe, Brandow and Petschek. \nIn the literature it is generally referred to as the\nBrueckner theory or the Brueckner-Bethe-Goldstone theory.\n\nSuppose we want to calculate the nuclear matter ground-state\nenergy $E_0$ using the non-relativistic Schr\\\"{o}dinger equation\n\n\n\n\n$$\n\\begin{equation}\n H\\Psi_0(A)=E_0(A)\\Psi_0(A),\n\\label{_auto21} \\tag{44}\n\\end{equation}\n$$\n\nwith $H=T+V$ where $A$ denotes the number of particles, $T$\nis the kinetic energy and $V$ is\nthe nucleon-nucleon\n(NN) potential. Models for the NN interaction are discussed in the chapter on nuclear forces.\nThe corresponding unperturbed\nproblem is\n\n\n\n\n$$\n\\begin{equation}\n H_0\\psi_0(A)=W_0(A)\\psi_0(A).\n\\label{_auto22} \\tag{45}\n\\end{equation}\n$$\n\nHere $H_0$ is just kinetic energy $T$ and $\\psi_0$ is a Slater\ndeterminant representing the Fermi sea, where all orbits through the\nFermi momentum $k_F$ are filled. We write\n\n\n\n\n$$\n\\begin{equation}\n E_0=W_0+\\Delta E_0,\n\\label{_auto23} \\tag{46}\n\\end{equation}\n$$\n\nwhere $\\Delta E_0$ is the ground-state energy shift or correlation energy as it was defined in many-body perturbation theory.\nIf we know how to calculate $\\Delta E_0$, then we know $E_0$, since\n$W_0$ is easily obtained. In the limit $A\\rightarrow \\infty$,\nthe quantities $E_0$ and $\\Delta E_0$ themselves are not well\ndefined, but the ratios $E_0/A$ and $\\Delta E_0/A$ are. The\nnuclear-matter binding energy per nucleon is commonly denoted\nby $BE/A$, which is just $-E_0/A$. In passing, we note that\nthe empirical value for symmetric nuclear matter (proton number\n$Z$=neutron number $N$) is $\\approx 16$ MeV.\nThere exists a formal theory for the calculation of $\\Delta E_0$.\nAccording to the well-known Goldstone linked-diagram theory, the energy shift $\\Delta E_0$ is given exactly by the\ndiagrammatic expansion shown in Fig. [fig:goldstone](#fig:goldstone). This theory,\nis a linked-cluster perturbation expansion for the ground state\nenergy of a many-body system, and applies equally well to both\nnuclear matter and closed-shell nuclei such as the doubly magic\nnucleus $^{40}$Ca. \nWe will not discuss the Goldstone expansion, but rather discuss\nbriefly how it is used in calculations.\n\n\n\n\n$n_{x}^{2}+n_{y}^{2}+n_{z}^{2}$ $n_{x}$ $n_{y}$ $n_{z}$ $N_{\\uparrow \\downarrow }$ 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\n# Unic Cell Determination and Stereographic Projection\n\n[Download](https://raw.githubusercontent.com/gduscher/MSE672-Introduction-to-TEM//main/Diffraction/CH2_09-Unit_Cell.ipynb)\n \n[](\n https://colab.research.google.com/github/gduscher/MSE672-Introduction-to-TEM/blob/main/Diffraction/CH2_09-Unit_Cell.ipynb)\n\n\n\npart of \n\n **[MSE672: Introduction to Transmission Electron Microscopy](../_MSE672_Intro_TEM.ipynb)**\n\nby Gerd Duscher, Spring 2021\n\nMicroscopy Facilities
\nJoint Institute of Advanced Materials
\nMaterials Science & Engineering
\nThe University of Tennessee, Knoxville\n\nBackground and methods to analysis and quantification of data acquired with transmission electron microscopes\n\n\n## Load relevant python packages\n### Check Installed Packages\n\n\n```python\nimport sys\nfrom pkg_resources import get_distribution, DistributionNotFound\n\ndef test_package(package_name):\n \"\"\"Test if package exists and returns version or -1\"\"\"\n try:\n version = get_distribution(package_name).version\n except (DistributionNotFound, ImportError) as err:\n version = '-1'\n return version\n\n# Colab setup ------------------\nif 'google.colab' in sys.modules:\n !pip install pyTEMlib -q\n# pyTEMlib setup ------------------\nelse:\n if test_package('pyTEMlib') < '0.2021.3.17':\n print('installing pyTEMlib')\n !{sys.executable} -m pip install --upgrade pyTEMlib -q\n# ------------------------------\nprint('done')\n```\n\n installing pyTEMlib\n done\n\n\n WARNING: You are using pip version 21.0; however, version 21.0.1 is available.\n You should consider upgrading via the 'C:\\Users\\nosle\\anaconda3\\python.exe -m pip install --upgrade pip' command.\n\n\n## Import numerical and plotting python packages\nImport the python packages that we will use:\n\nBeside the basic numerical (numpy) and plotting (pylab of matplotlib) libraries,\n\nand some libraries from the book\n* kinematic scattering library.\n\n\n```python\n# import matplotlib and numpy\n# use \"inline\" instead of \"notebook\" for non-interactive plots\nimport sys\nif 'google.colab' in sys.modules:\n %pylab --no-import-all inline\nelse:\n %pylab --no-import-all notebook\n \n# additional package \nimport itertools \nfrom matplotlib import patches\n\n# Import libraries from the book\n\n# Import libraries from pyTEMlib\nimport pyTEMlib\nimport pyTEMlib.KinsCat as ks # Kinematic sCattering Library\n # Atomic form factors from Kirklands book\n\n__notebook_version__ = '2021.02.17'\nprint('pyTEM version: ', pyTEMlib.__version__)\nprint('notebook version: ', __notebook_version__)\n```\n\n Populating the interactive namespace from numpy and matplotlib\n Using KinsCat library version 0.5 by G.Duscher\n spglib not installed; Symmetry functions of spglib disabled\n pyTEM version: 0.2021.02.17\n notebook version: 2021.02.17\n\n\n C:\\Users\\nosle\\anaconda3\\lib\\site-packages\\pyUSID\\viz\\__init__.py:16: FutureWarning: Please use sidpy.viz.plot_utils instead of pyUSID.viz.plot_utils. pyUSID.plot_utils will be removed in a future release of pyUSID\n warn('Please use sidpy.viz.plot_utils instead of pyUSID.viz.plot_utils. '\n\n\n## Unit Cell Determination\n\n- The HOLZ rings will give the lattice repeat vector (reciprocal vector parallel to the zone axis).\n- So tilting in [001] zone axis, the ZOLZ pattern will give you the [100] and [010] distance \n- and the HOLZ ring radius the [001] distance.\n\n> **This is the determination of the lattice parameter of a unit cell.**\n>\n>Thus, we see that one can determine 3D information from a single two dimensional pattern. \n>\n>It might be necessary to use other low order zone axes.\n\n### Measurements\n\n- Record HOLZ and ZOLZ patterns, if possible in one picture (use double illumination with different exposure times to enhance dynamic range), but with different convergence angles.\n- If the angle of the ring is too large then your measurements may suffer from lens distortions.\n- If the HOLZ ring is split measure the inner one.\n\n### Z-Component of Unit Cell\n\nIf $H$ is the distance between the reciprocal-lattice planes parallel to the beam and $G_n$ is the projected radius of the HOLZ ring, then \n\\begin{eqnarray}\nG_1&=& \\left( \\frac{2H}{\\lambda}\\right)^{1/2} = \\sqrt{\\frac{2H}{\\lambda}}\\\\\nG_2&=& 2\\left( \\frac{H}{\\lambda}\\right)^{1/2} = 2 \\sqrt{\\frac{H}{\\lambda}}\n\\end{eqnarray}\nfor FOLZ and SOLZ. \n\nSimilar expressions can be developed for higher order HOLZ rings.\n\nIn real space you get for example for FOLZ:\n\\begin{equation}\n\\frac{1}{H}=\\frac{2}{\\lambda G_1^2} = \\frac{2}{\\lambda} \\left(\\frac{\\lambda L}{r}\\right)^{2}\n\\end{equation}\n\nIf you did use a zone axis which is not ${100}$, then you have to compare your result to calculated values.\n\nAssuming you are looking down $[UVW]$ then we know:\n\\begin{equation}\n\\frac{1}{H}= |[UVW]|\n\\end{equation}\n\nNow we have to calculate this $|[UVW]|$ for different structures:\\\\\n#### for fcc:\n\\begin{equation}\n\\frac{1}{H}= \\frac{a_0}{p(U^2+V^2+W^2)}\n\\end{equation}\nwith $a_0$ is the lattice parameter and $p=1$ for $U+V+W$ is odd; $p=2$ for $U+V+W$ is even.\n\n\n#### for bcc:\nthe same relationship as for fcc is true for bcc but $p$ is different: $p=2$ for $U$, $V$, and $W$ all odd; $p=1$ otherwise.\n\n\nLook up other crystal systems.\n\nIf a ring is forbidden: you have to multiply your measurement $1/H_m$ with an integer $n$ to obtain the distance of the crystal.\n\n\n## Lattice Centering\n\nWe are going to look at cubic structures to \n- fcc\n- bcc \n- a-face\n- b-face\n- primitive or simple cubic\n\nThe maximal excitation error is chosen so that ZOLZ and FOLZ overlap and we can see the different centering \n\n\n```python\ndef plot_spots(tags, ax):\n \"\"\"Simple plotting for spot pattern\"\"\"\n \n points = tags['allowed']['g']\n ix = np.argsort((points**2).sum(axis=1))\n p = points[ix]\n Laue_zones = np.unique(p[:,2]) \n ZOLZ = np.where(p[:,2] == Laue_zones[0])\n FOLZ = np.where(p[:,2] == Laue_zones[1])\n SOLZ = np.where(p[:,2] == Laue_zones[2])\n\n ax.scatter(p[ZOLZ,0], p[ZOLZ,1], color='red')\n ax.scatter(p[FOLZ,0], p[FOLZ,1], color='blue', alpha = 0.3)\n ax.scatter(p[SOLZ,0], p[SOLZ,1], color='green', alpha = 0.3)\n\n ax.set_aspect('equal')\n ax.set_title(tags['crystal_name'])\n ax.set_xlim(-40,40)\n ax.set_ylim(-40,40)\n \n# load structure\ntags = ks.structure_by_name('FCC Fe')\n\n# add necessary parameters for kinematic scattering calculation\ntags['acceleration_voltage_V'] = 200000\ntags['convergence_angle_mrad'] = 0\ntags['zone_hkl'] = [0, 0, 1] # incident neares zone axis: defines Laue Zones!!!!\ntags['mistilt'] = np.array([0,0,0]) # mistilt in degrees\n\ntags['Sg_max'] = 2.5 # 1/nm maximum allowed excitation error ; This parameter is related to the thickness\ntags['hkl_max'] = 15 # Highest evaluated Miller indices\n# calulcuate kinematic scattering data\nks.kinematic_scattering(tags, False)\n\nfig, ax = plt.subplots(nrows=2, ncols=3, figsize=(10,6))\n\n\n# plot diffraction pattern\nplot_spots(tags, ax[0, 0])\ntags['crystal_name'] = 'FCC or I'\nplot_spots(tags, ax[1, 2])\n\n\ntags.update(ks.structure_by_name('BCC Fe'))\nks.kinematic_scattering(tags, False)\n\n# plot diffraction pattern\nplot_spots(tags, ax[1, 0])\n\ntags['crystal_name'] = 'a-face'\ntags['base'] = np.array([[0. , 0. , 0. ], [0, 1/2, 1/2]])\nks.kinematic_scattering(tags, False)\nplot_spots(tags, ax[0, 1])\n\ntags['crystal_name'] = 'b-face'\ntags['base'] = np.array([[0. , 0. , 0. ], [1/2, 0, 1/2]])\nks.kinematic_scattering(tags, False)\nplot_spots(tags, ax[1, 1])\n\ntags['crystal_name'] = 'simple cubic'\ntags['base'] = np.array([[0. , 0. , 0. ]])\ntags['elements'] = ['Fe']\nks.kinematic_scattering(tags, False)\nplot_spots(tags, ax[0, 2])\n\n\n```\n\n\n
\n\n
\n\n
\n\nAppend mean approach SPD representation with \"siegel\" option for **compute_cov()** (cf. next notebook cell):\n\n
\n\n\\begin{equation}\n\\begin{pmatrix}\n\\Sigma+ \\beta^2 \\mu \\mu^T & \\beta \\mu \\\\\n\\beta \\mu^T & 1\n\\end{pmatrix}\n\\end{equation}\n\n
\n\nAppend mean approach SPD representation with \"siegel2\" option for **compute_cov()** (cf. next notebook cell):\n\n
\n\n\\begin{equation}\n\\begin{pmatrix}\n\\Sigma+ \\beta \\mu \\mu^T & \\beta \\mu \\\\\n\\beta \\mu^T & \\beta\n\\end{pmatrix}\n\\end{equation}\n\n
\n\nIn the previous equations, beta is a constant, sigma the covariance matrix, and mu the mean vector.\n\n\n```python\ndef compute_cov(xout,option='simple'):\n resC=[]\n if option=='simple':\n for i in range(xout.shape[0]):\n C=np.cov(xout[i,:,:].T)\n resC.append(C)\n elif option=='siegel': # append mean from equation 2 here https://arxiv.org/pdf/1703.06817.pdf\n beta=.3 # Constant recommended in https://arxiv.org/pdf/1703.06817.pdf\n for i in range(xout.shape[0]):\n C=np.cov(xout[i,:,:].T)\n m=np.expand_dims(np.mean(xout[i,:,:],axis=0),axis=-1)\n resC.append(np.concatenate([np.concatenate([C+(beta**2)*(m*m.T),beta*m],axis=1),np.concatenate([beta*m,np.ones([1,1])],axis=0).T]))\n elif option=='siegel2': # append mean from lemma 3.1 here https://core.ac.uk/download/pdf/82584625.pdf\n beta=.3 #Constant recommended in https://arxiv.org/pdf/1703.06817.pdf\n for i in range(xout.shape[0]):\n C=np.cov(xout[i,:,:].T)\n m=np.expand_dims(np.mean(xout[i,:,:],axis=0),axis=-1)\n resC.append(np.concatenate([np.concatenate([C+beta*(m*m.T),beta*m],axis=1),np.concatenate([beta*m,beta*np.ones([1,1])],axis=0).T]))\n return np.array(resC)\n```\n\n\n```python\nx_train1_transformations = compute_transformation(x_train1)\nx_test1_transformations = compute_transformation(x_test1)\nx_test2_transformations = compute_transformation(x_test2)\n\nfig, ax = plt.subplots(2,11,figsize=(20,5))\nfor transf_index1 in range(2):\n for transf_index2 in range(11):\n ax[transf_index1,transf_index2].imshow(x_train1_transformations[0,:,:,0,transf_index2+11*(transf_index1==1)])\nax[0,5].set_title('Image transformations accumulated in order to compute \\na covariance matrix along the horizontal or vertical axis\\n', fontsize=20)\n```\n\n\n```python\nx_train1_transformations = reshape_byaxis(x_train1_transformations, axis=axis_to_cov)\nx_test1_transformations = reshape_byaxis(x_test1_transformations, axis=axis_to_cov)\nx_test2_transformations = reshape_byaxis(x_test2_transformations, axis=axis_to_cov)\n\nSPD_train1 = compute_cov(x_train1_transformations, option=cov_type)\nSPD_test1 = compute_cov(x_test1_transformations, option=cov_type)\nSPD_test2 = compute_cov(x_test2_transformations, option=cov_type)\n```\n\n\n```python\nfig, ax = plt.subplots(1,2,figsize=(20,8))\nax[0].imshow(x_train1[3])\nax[0].set_title('Untransformed input image', fontsize=20)\nax[1].imshow(SPD_train1[3])\nax[1].set_title('SPD representation of the image \\n(notice the append mean approach illuminating the last column & row)', fontsize=20)\n\nfig, ax = plt.subplots(1,2,figsize=(20,8))\nax[0].imshow(x_test2[7])\nax[0].set_title('Untransformed input image', fontsize=20)\nax[1].imshow(SPD_test2[7])\nax[1].set_title('SPD representation of the image \\n(notice the append mean approach illuminating the last column & row)', fontsize=20)\n```\n\n## 2.3. AD with Riemannian distance to Fréchet mean \n\nA Riemannian metric must be chosen among those available in Geomstats, in order to compute the Fréchet mean and the distance to this mean\n\n\n```python\ndim = SPD_train1[0].shape[1]\n# riem_metric = spd.SPDMetricAffine(dim)\nriem_metric = spd.SPDMetricLogEuclidean(dim)\n```\n\nCompute Fréchet SPD matrices mean according to previously chosen SPD metric:\n\n\n```python\nFM = FrechetMean(riem_metric).fit(SPD_train1)\n\nplt.imshow(FM.estimate_)\nplt.title('Fréchet mean of our normal class training samples')\nplt.show()\n```\n\nCompute distances of test samples to Fréchet mean:\n\n\n```python\nriemdist_test1 = riem_metric.dist(FM.estimate_,np.array(SPD_test1))\nplt.hist(riemdist_test1, alpha=0.2, color='r', bins=100)\n\nriemdist_test2 = riem_metric.dist(FM.estimate_,np.array(SPD_test2))\nplt.hist(riemdist_test2, alpha=0.2, color='g', bins=100)\n\nplt.title('Outlier Score for the two classes')\nplt.show()\n```\n\nROC AUC achieved:\n\n\n```python\nprint(roc_auc_score(np.concatenate([np.zeros(len(SPD_test1)),np.ones(len(SPD_test2))]),np.concatenate([riemdist_test1, riemdist_test2])))\n```\n\n 0.7279720000000001\n\n\n\n```python\nresults_dic['dist_frechet_mean'] = roc_auc_score(np.concatenate([np.zeros(len(SPD_test1)),np.ones(len(SPD_test2))]),np.concatenate([riemdist_test1, riemdist_test2]))\n```\n\n## 2.4. AD with norm of negated geodesic PCA \n\nUse norm of negated geodesic PCA as detector [[3]](#[3]), with the previously computed Riemannian mean as PCA base point:\n\n\n```python\ntpca = TangentPCA(metric=riem_metric, n_components=n_components_PCA)\ntpca = tpca.fit(SPD_train1, base_point=FM.estimate_)\n\ntangent_projected_data_test1 = tpca.transform(SPD_test1)\ntangent_projected_data_test2 = tpca.transform(SPD_test2)\n```\n\n\n```python\nscores = []\nfor var in range(0,19):\n scores.append(roc_auc_score(np.concatenate([np.zeros(len(SPD_test1)),np.ones(len(SPD_test2))]),np.concatenate([np.sum(tangent_projected_data_test1[:,var:]**2,axis=1),np.sum(tangent_projected_data_test2[:,var:]**2,axis=1)])))\n\nprint(\"Best ROC AUC is: {} for norm of {} last PCA dimensions\".format(max(scores), 20-scores.index(max(scores))))\n```\n\n Best ROC AUC is: 0.8808370000000001 for norm of 14 last PCA dimensions\n\n\n\n```python\nnegPCAscore_test1 = np.sum(tangent_projected_data_test1[:,scores.index(max(scores)):]**2,axis=1)\nplt.hist(negPCAscore_test1, alpha=0.2, color='r', bins=100)\n\nnegPCAscore_test2 = np.sum(tangent_projected_data_test2[:,scores.index(max(scores)):]**2,axis=1)\nplt.hist(negPCAscore_test2, alpha=0.2, color='g', bins=100)\n\nplt.title('Outlier Score for the two classes')\nplt.show()\n```\n\n\n```python\nresults_dic['negated geodesic PCA'] = max(scores)\n```\n\n## 2.5. AD with norm of negated geodesic PCA with Giotto-TDA preprocessing \n\n\n```python\nclass giotto_preprocessing():\n def __init__(self, x_train, filter_name):\n self.filter_name = filter_name\n if self.filter_name == 'dilation':\n self.filter = DilationFiltration()\n elif self.filter_name == 'erosion':\n self.filter = ErosionFiltration()\n elif self.filter_name == 'density':\n self.filter = DensityFiltration()\n elif self.filter_name == 'radial':\n self.filter = RadialFiltration()\n else: \n raise NoValidGiottoFilterError\n self.filter.fit(x_train)\n \n def transform(self, x):\n return self.filter.transform(x)\n```\n\nBinarize data to be able to apply Giotto-TDA filter:\n\n\n```python\nbinarizer = Binarizer(threshold=binarize_threshold) \nx_train1 = binarizer.fit_transform(x_train1)\n\nx_test1 = binarizer.transform(x_test1)\nx_test2 = binarizer.transform(x_test2)\n```\n\nDefine Giotto-TDA filter:\n\n\n```python\ngfilter = giotto_preprocessing(x_train1, gfiltertype)\n```\n\nTransform train and test data with Giotto-TDA filter and compute new SPD representations:\n\n\n```python\nx_train1_filtered = gfilter.transform(x_train1)\n\nx_test1_filtered = gfilter.transform(x_test1)\nx_test2_filtered = gfilter.transform(x_test2)\n```\n\n\n```python\nx_train1_transformations_filtered = compute_transformation(x_train1_filtered)\nx_test1_transformations_filtered = compute_transformation(x_test1_filtered)\nx_test2_transformations_filtered = compute_transformation(x_test2_filtered)\n\nx_train1_transformations_filtered = reshape_byaxis(x_train1_transformations_filtered, axis=axis_to_cov)\nx_test1_transformations_filtered = reshape_byaxis(x_test1_transformations_filtered, axis=axis_to_cov)\nx_test2_transformations_filtered = reshape_byaxis(x_test2_transformations_filtered, axis=axis_to_cov)\n\nSPD_train1_filtered = compute_cov(x_train1_transformations_filtered, option=cov_type)\nSPD_test1_filtered = compute_cov(x_test1_transformations_filtered, option=cov_type)\nSPD_test2_filtered = compute_cov(x_test2_transformations_filtered, option=cov_type)\n```\n\n\n```python\nfig, ax = plt.subplots(1,2,figsize=(20,8))\nax[0].imshow(x_train1_filtered[3])\nax[0].set_title('Filtered input image', fontsize=20)\nax[1].imshow(SPD_train1_filtered[3])\nax[1].set_title('SPD representation of the filtered image', fontsize=20)\n\nfig, ax = plt.subplots(1,2,figsize=(20,8))\nax[0].imshow(x_test2_filtered[7])\nax[0].set_title('Filtered input image', fontsize=20)\nax[1].imshow(SPD_test2_filtered[7])\nax[1].set_title('SPD representation of the filtered image', fontsize=20)\n```\n\nA new Riemannian mean needs to be computed in order to compute the PCA base point:\n\n\n```python\ndim = SPD_train1_filtered[0].shape[1]\n# riem_metric = spd.SPDMetricAffine(dim)\nriem_metric = spd.SPDMetricLogEuclidean(dim)\n```\n\n\n```python\nFM = FrechetMean(riem_metric).fit(SPD_train1_filtered)\nFM.estimate_\n\nplt.imshow(FM.estimate_)\nplt.title('Fréchet mean of our normal class filtered training samples')\nplt.show()\n```\n\n\n```python\ntpca = TangentPCA(metric=riem_metric, n_components=n_components_PCA)\ntpca = tpca.fit(SPD_train1_filtered, base_point=FM.estimate_)\n\ntangent_projected_fdata_test1 = tpca.transform(SPD_test1_filtered)\ntangent_projected_fdata_test2 = tpca.transform(SPD_test2_filtered)\n```\n\n\n```python\nscores = []\nfor var in range(0,19):\n scores.append(roc_auc_score(np.concatenate([np.zeros(len(SPD_test1_filtered)),np.ones(len(SPD_test1_filtered))]),np.concatenate([np.sum(tangent_projected_fdata_test1[:,var:]**2,axis=1),np.sum(tangent_projected_fdata_test2[:,var:]**2,axis=1)])))\n\nprint(\"Best ROC AUC is: {} for norm of {} last PCA dimensions\".format(max(scores), 20-scores.index(max(scores))))\n```\n\n Best ROC AUC is: 0.887529 for norm of 13 last PCA dimensions\n\n\n\n```python\nnegPCAscore_test1 = np.sum(tangent_projected_fdata_test1[:,scores.index(max(scores)):]**2,axis=1)\nplt.hist(negPCAscore_test1, alpha=0.2, color='r', bins=100)\n\nnegPCAscore_test2 = np.sum(tangent_projected_fdata_test2[:,scores.index(max(scores)):]**2,axis=1)\nplt.hist(negPCAscore_test2, alpha=0.2, color='g', bins=100)\n\nplt.title('Outlier Score for the two classes')\nplt.show()\n```\n\n\n```python\nresults_dic['negated geodesic PCA with preprocessing filter'] = max(scores)\n```\n\n## 2.6. Role of Geomstats/Giotto-TDA in the analysis \n\n
\n\n\n \n
\n\n \n \n \n \n Picture 1 \n Picture 2 \n Picture 3 \n Sky \n Tree \n \n \n Picture 1 \n 0 \n 0 \n 0 \n 1 \n 1 \n \n \n Picture 2 \n 0 \n 0 \n 0 \n 1 \n 0 \n \n \n Picture 3 \n 0 \n 0 \n 0 \n 1 \n 1 \n \n \n Sky \n 1 \n 1 \n 1 \n 0 \n 0 \n \n \n \nTree \n 1 \n 0 \n 1 \n 0 \n 0 \n \n \n
\n\n \n \n \n \n Picture 1 \n Picture 2 \n Picture 3 \n Sky \n Tree \n \n \n Picture 1 \n 0.0 \n 0 \n 0.0 \n 0.333333 \n 0.5 \n \n \n Picture 2 \n 0.0 \n 0 \n 0.0 \n 0.333333 \n 0.0 \n \n \n Picture 3 \n 0.0 \n 0 \n 0.0 \n 0.333333 \n 0.5 \n \n \n Sky \n 0.5 \n 1 \n 0.5 \n 0.000000 \n 0.0 \n \n \n \nTree \n 0.5 \n 0 \n 0.5 \n 0.000000 \n 0.0 \n \n \n
\n\n \n \n \n \n e_0 \n \n \n Picture 1 \n 1 \n \n \n Picture 2 \n 0 \n \n \n Picture 3 \n 0 \n \n \n Sky \n 0 \n \n \n \nTree \n 0 \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 ... \n 41 \n 42 \n 43 \n 44 \n 45 \n 46 \n 47 \n 48 \n 49 \n 50 \n \n \n Picture 1 \n 1 \n 0.2 \n 0.466667 \n 0.253333 \n 0.418311 \n 0.286329 \n 0.391308 \n 0.307325 \n 0.374446 \n 0.320749 \n ... \n 0.344591 \n 0.344625 \n 0.344598 \n 0.344620 \n 0.344603 \n 0.344616 \n 0.344605 \n 0.344614 \n 0.344607 \n 0.344613 \n \n \n Picture 2 \n 0 \n 0.0 \n 0.106667 \n 0.021333 \n 0.100978 \n 0.037262 \n 0.089448 \n 0.047699 \n 0.081228 \n 0.054405 \n ... \n 0.066326 \n 0.066343 \n 0.066329 \n 0.066340 \n 0.066331 \n 0.066338 \n 0.066333 \n 0.066337 \n 0.066333 \n 0.066336 \n \n \n Picture 3 \n 0 \n 0.0 \n 0.266667 \n 0.053333 \n 0.218311 \n 0.086329 \n 0.191308 \n 0.107325 \n 0.174446 \n 0.120749 \n ... \n 0.144591 \n 0.144625 \n 0.144598 \n 0.144620 \n 0.144603 \n 0.144616 \n 0.144605 \n 0.144614 \n 0.144607 \n 0.144613 \n \n \n Sky \n 0 \n 0.4 \n 0.080000 \n 0.378667 \n 0.139733 \n 0.335431 \n 0.178873 \n 0.304605 \n 0.204019 \n 0.284540 \n ... \n 0.248785 \n 0.248734 \n 0.248774 \n 0.248742 \n 0.248768 \n 0.248747 \n 0.248764 \n 0.248750 \n 0.248761 \n 0.248752 \n \n \n \nTree \n 0 \n 0.4 \n 0.080000 \n 0.293333 \n 0.122667 \n 0.254649 \n 0.149063 \n 0.233046 \n 0.165860 \n 0.219557 \n ... \n 0.195707 \n 0.195673 \n 0.195700 \n 0.195679 \n 0.195696 \n 0.195682 \n 0.195693 \n 0.195684 \n 0.195691 \n 0.195686 \n \n \n
\n\n \n \n \n \n name \n keyword \n s \n betx \n alfx \n mux \n bety \n alfy \n muy \n x \n ... \n sig54 \n sig55 \n sig56 \n sig61 \n sig62 \n sig63 \n sig64 \n sig65 \n sig66 \n n1 \n \n \n #s \n mycell$start:1 \n marker \n 0.0 \n 463.623288 \n -1.156109 \n 0.000000 \n 369.779162 \n 0.929316 \n 0.000000 \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.0 \n \n \n quadrupole1 \n quadrupole1:1 \n quadrupole \n 5.0 \n 463.623288 \n 1.156109 \n 0.001709 \n 369.779162 \n -0.929316 \n 0.002161 \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.0 \n \n \n drift_0[0] \n drift_0:0 \n drift \n 25.0 \n 419.394867 \n 1.055312 \n 0.008930 \n 408.967742 \n -1.030113 \n 0.010350 \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.0 \n \n \n marker1 \n marker1:1 \n marker \n 25.0 \n 419.394867 \n 1.055312 \n 0.008930 \n 408.967742 \n -1.030113 \n 0.010350 \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.0 \n \n \n drift_1[0] \n drift_1:0 \n drift \n 50.0 \n 369.779162 \n 0.929316 \n 0.019041 \n 463.623288 \n -1.156109 \n 0.019493 \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.0 \n \n \n quadrupole2 \n quadrupole2:1 \n quadrupole \n 55.0 \n 369.779162 \n -0.929316 \n 0.021202 \n 463.623288 \n 1.156109 \n 0.021202 \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.0 \n \n \n drift_2[0] \n drift_2:0 \n drift \n 100.0 \n 463.623288 \n -1.156109 \n 0.038533 \n 369.779162 \n 0.929316 \n 0.038533 \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.0 \n \n \n \n#e \n mycell$end:1 \n marker \n 100.0 \n 463.623288 \n -1.156109 \n 0.038533 \n 369.779162 \n 0.929316 \n 0.038533 \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.0 \n \n \n
\n\n \n \n \n \n name \n s \n betx \n bety \n alfx \n alfy \n \n \n #s \n mycell$start:1 \n 0.0 \n 463.623288 \n 369.779162 \n -1.156109 \n 0.929316 \n \n \n quadrupole1 \n quadrupole1:1 \n 5.0 \n 463.623288 \n 369.779162 \n 1.156109 \n -0.929316 \n \n \n drift_0[0] \n drift_0:0 \n 25.0 \n 419.394867 \n 408.967742 \n 1.055312 \n -1.030113 \n \n \n marker1 \n marker1:1 \n 25.0 \n 419.394867 \n 408.967742 \n 1.055312 \n -1.030113 \n \n \n drift_1[0] \n drift_1:0 \n 50.0 \n 369.779162 \n 463.623288 \n 0.929316 \n -1.156109 \n \n \n quadrupole2 \n quadrupole2:1 \n 55.0 \n 369.779162 \n 463.623288 \n -0.929316 \n 1.156109 \n \n \n drift_2[0] \n drift_2:0 \n 100.0 \n 463.623288 \n 369.779162 \n -1.156109 \n 0.929316 \n \n \n \n#e \n mycell$end:1 \n 100.0 \n 463.623288 \n 369.779162 \n -1.156109 \n 0.929316 \n \n \n
\n\n \n \n \n \n length \n orbit5 \n alfa \n gammatr \n q1 \n dq1 \n betxmax \n dxmax \n dxrms \n xcomax \n ... \n ycorms \n deltap \n synch_1 \n synch_2 \n synch_3 \n synch_4 \n synch_5 \n synch_6 \n synch_8 \n nflips \n \n \n \n#e \n 100.0 \n -0.0 \n 0.0 \n 0.0 \n 0.038533 \n -0.043847 \n 463.623288 \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.0 \n \n \n
\n\n \n \n \n \n sm \n d1 \n d2 \n pd1 \n pd2 \n p \n \n \n (1, 1) \n 2 \n 1 \n 1 \n NaN \n NaN \n NaN \n \n \n (1, 2) \n 3 \n 1 \n 2 \n NaN \n NaN \n NaN \n \n \n (1, 3) \n 4 \n 1 \n 3 \n NaN \n NaN \n NaN \n \n \n (1, 4) \n 5 \n 1 \n 4 \n NaN \n NaN \n NaN \n \n \n \n(1, 5) \n 6 \n 1 \n 5 \n NaN \n NaN \n NaN \n \n \n
\n\n \n \n \n \n sm \n d1 \n d2 \n pd1 \n pd2 \n p \n \n \n (1, 1) \n 2 \n 1 \n 1 \n 0.111111 \n 0.166667 \n NaN \n \n \n (1, 2) \n 3 \n 1 \n 2 \n 0.111111 \n 0.166667 \n NaN \n \n \n (1, 3) \n 4 \n 1 \n 3 \n 0.111111 \n 0.166667 \n NaN \n \n \n (1, 4) \n 5 \n 1 \n 4 \n 0.111111 \n 0.166667 \n NaN \n \n \n (1, 5) \n 6 \n 1 \n 5 \n 0.111111 \n 0.166667 \n NaN \n \n \n (1, 6) \n 7 \n 1 \n 6 \n 0.111111 \n 0.166667 \n NaN \n \n \n (2, 1) \n 3 \n 2 \n 1 \n 0.111111 \n 0.166667 \n NaN \n \n \n (2, 2) \n 4 \n 2 \n 2 \n 0.111111 \n 0.166667 \n NaN \n \n \n (2, 3) \n 5 \n 2 \n 3 \n 0.111111 \n 0.166667 \n NaN \n \n \n \n(2, 4) \n 6 \n 2 \n 4 \n 0.111111 \n 0.166667 \n NaN \n \n \n
\n\n \n \n \n \n sm \n d1 \n d2 \n pd1 \n pd2 \n p \n \n \n (1, 1) \n 2 \n 1 \n 1 \n 0.111111 \n 0.166667 \n 0.0185185 \n \n \n (1, 2) \n 3 \n 1 \n 2 \n 0.111111 \n 0.166667 \n 0.0185185 \n \n \n (1, 3) \n 4 \n 1 \n 3 \n 0.111111 \n 0.166667 \n 0.0185185 \n \n \n (1, 4) \n 5 \n 1 \n 4 \n 0.111111 \n 0.166667 \n 0.0185185 \n \n \n \n(1, 5) \n 6 \n 1 \n 5 \n 0.111111 \n 0.166667 \n 0.0185185 \n \n
\n\n## Abstract\n\n\nIn this colab we demonstrate how to fit a Generalized Linear Mixed-effects Model using Variational Inference and TensorFlow.\n\n\n## Model Family\n\n[Generalized linear mixed-effect models](https://en.wikipedia.org/wiki/Generalized_linear_mixed_model) (GLMM) are similar to [generalized linear models](https://en.wikipedia.org/wiki/Generalized_linear_model) (GLM) except that they incorporate a sample specific noise into the predicted linear response. This is useful in part because it allows rarely seen features to share information with more commonly seen features.\n\n\nAs a generative process, a Generalized Linear Mixed-effects Model (GLMM) is characterized by:\n\n$$\n\\begin{align}\n\\text{for } & r = 1\\ldots R: \\hspace{2.45cm}\\text{# for each random-effect group}\\\\\n &\\begin{aligned}\n \\text{for } &c = 1\\ldots |C_r|: \\hspace{1.3cm}\\text{# for each category (\"level\") of group $r$}\\\\\n &\\begin{aligned}\n \\beta_{rc}\n &\\sim \\text{MultivariateNormal}(\\text{loc}=0_{D_r}, \\text{scale}=\\Sigma_r^{1/2})\n \\end{aligned}\n\\end{aligned}\\\\\\\\\n\\text{for } & i = 1 \\ldots N: \\hspace{2.45cm}\\text{# for each sample}\\\\\n&\\begin{aligned}\n &\\eta_i = \\underbrace{\\vphantom{\\sum_{r=1}^R}x_i^\\top\\omega}_\\text{fixed-effects} + \\underbrace{\\sum_{r=1}^R z_{r,i}^\\top \\beta_{r,C_r(i) }}_\\text{random-effects} \\\\\n &Y_i|x_i,\\omega,\\{z_{r,i} , \\beta_r\\}_{r=1}^R \\sim \\text{Distribution}(\\text{mean}= g^{-1}(\\eta_i))\n\\end{aligned}\n\\end{align}\n$$\n\n\n\nwhere:\n\n$$\n\\begin{align}\nR &= \\text{number of random-effect groups}\\\\\n|C_r| &= \\text{number of categories for group $r$}\\\\\nN &= \\text{number of training samples}\\\\\nx_i,\\omega &\\in \\mathbb{R}^{D_0}\\\\\nD_0 &= \\text{number of fixed-effects}\\\\\nC_r(i) &= \\text{category (under group $r$) of the $i$th sample}\\\\\nz_{r,i} &\\in \\mathbb{R}^{D_r}\\\\\nD_r &= \\text{number of random-effects associated with group $r$}\\\\\n\\Sigma_{r} &\\in \\{S\\in\\mathbb{R}^{D_r \\times D_r} : S \\succ 0 \\}\\\\\n\\eta_i\\mapsto g^{-1}(\\eta_i) &= \\mu_i, \\text{inverse link function}\\\\\n\\text{Distribution} &=\\text{some distribution parameterizable solely by its mean}\n\\end{align}\n$$\n\n\nIn words, this says that every category of each group is associated with an iid MVN, $\\beta_{rc}$. Although the $\\beta_{rc}$ draws are always independent, they are only indentically distributed for a group $r$; notice there is exactly one $\\Sigma_r$ for each $r\\in\\{1,\\ldots,R\\}$.\n\nWhen affinely combined with a sample's group's features ($z_{r,i}$), the result is sample-specific noise on the $i$-th predicted linear response (which is otherwise $x_i^\\top\\omega$).\n\nWhen we estimate $\\{\\Sigma_r:r\\in\\{1,\\ldots,R\\}\\}$ we're essentially estimating the amount of noise a random-effect group carries which would otherwise drown out the signal present in $x_i^\\top\\omega$.\n\nThere are a variety of options for the $\\text{Distribution}$ and [inverse link function](https://en.wikipedia.org/wiki/Generalized_linear_model#Link_function), $g^{-1}$. Common choices are:\n- $Y_i\\sim\\text{Normal}(\\text{mean}=\\eta_i, \\text{scale}=\\sigma)$,\n- $Y_i\\sim\\text{Binomial}(\\text{mean}=n_i \\cdot \\text{sigmoid}(\\eta_i), \\text{total_count}=n_i)$, and, \n- $Y_i\\sim\\text{Poisson}(\\text{mean}=\\exp(\\eta_i))$.\n\nFor more possibilities, see the [`tfp.glm`](https://github.com/tensorflow/probability/tree/master/tensorflow_probability/python/glm) module.\n\n## Variational Inference\n\nUnfortunately, finding the maximum likelihood estimates of the parameters $\\beta,\\{\\Sigma_r\\}_r^R$ entails a non-analytical integral. To circumvent this problem, we instead find the parameters which minimize an upper bound. Writing $\\phi(x)=\\exp(-x^2/2)/\\sqrt{2\\pi}$ we find:\n\n$\\begin{align}\n-\\log \\overbrace{p(\\{y\\}_i^N|\\{x_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R)}^{\\text{evidence}}\n& = -\\log \\int_{\\mathbb{R}^{\\sum_r |C_r|D_r}} \\overbrace{\\left(\\prod_i^N p(y_i | \\eta_i(u)) \\right)}^{\\text{likelihood}} \\overbrace{\\left(\\prod_r^R |\\Sigma_r^{-1/2}| \\prod_c^{|C_r|} \\phi(\\Sigma_r^{-1/2} u_{rc}) \\right)}^{\\text{prior}} \\, du\\\\\n& = -\\log \\int_{\\mathbb{R}^{\\sum_r |C_r|D_r}} \\frac{\n q_\\lambda(u|\\{x_i,y_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R)\n }{\n q_\\lambda(u|\\{x_i,y_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R)} \\left( \\prod_i^N p(y_i | \\eta_i(u)) \\right) \\left(\\prod_r^R |\\Sigma_r^{-1/2}| \\prod_c^{|C_r|} \\phi(\\Sigma_r^{-1/2} u_{rc}) \\right) \\, du\\\\\n& \\le \\text{E}_{q_\\lambda(U|\\{x_i,y_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R)} \\left[ -\\log\n\\frac{\n \\left( \\prod_i^N p(y_i | \\eta_i(U)) \\right) \\left(\\prod_r^R |\\Sigma_r^{-1/2}| \\prod_c^{|C_r|} \\phi(\\Sigma_r^{-1/2} U_{rc}) \\right)\n }{\n q_\\lambda(U|\\{x_i,y_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R)\n } \\right]\\\\\n&= \\text{KL}\\left[q_\\lambda(U|\\{x_i,y_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R) \\Bigg| \\left( \\prod_i^N p(y_i | \\eta_i(U)) \\right) \\left(\\prod_r^R |\\Sigma_r^{-1/2}| \\prod_c^{|C_r|} \\phi(\\Sigma_r^{-1/2} U_{rc}) \\right) \\right]\n\\end{align}$\n\nThe inequality follows from [Jensen's Inequality](https://en.wikipedia.org/wiki/Jensen%27s_inequality).\n\nSo, instead of solving:\n\n$$\\begin{align}\n\\{\\beta^*, \\{\\Sigma_r^*\\}_r^R\\} = \\operatorname{\\arg\\min}_{\\beta,\\{\\Sigma_r\\}_r^R} \\left\\{\n -\\log p(\\{y\\}_i^N|\\{x_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R)\n\\right\\}\n\\end{align}$$\n\nwe solve:\n\n$$\\begin{align}\n\\{\\lambda^*, \\beta^*, \\{\\Sigma_r^*\\}_r^R\\} = \\operatorname{\\arg\\min}_{\\lambda,\\beta,\\{\\Sigma_r\\}_r^R} \\left\\{\n\\text{KL}\\left[q_\\lambda(U|\\{x_i,y_i,z_i\\}_i^N,\\beta,\\{\\Sigma_r\\}_r^R) \\Bigg| \\left( \\prod_i^N p(y_i | \\eta_i(U)) \\right) \\left(\\prod_r^R |\\Sigma_r^{-1/2}| \\prod_c^{|C_r|} \\phi(\\Sigma_r^{-1/2} U_{rc}) \\right) \\right]\n\\right\\}\n\\end{align}$$\n\n## Toy Problem\n\n[Gelman et al.'s (2007) \"radon dataset\"](http://www.stat.columbia.edu/~gelman/arm/) is a dataset sometimes used to demonstrate approaches for regression. (E.g., this closely related [PyMC3 blog post](http://twiecki.github.io/blog/2014/03/17/bayesian-glms-3/).) The radon dataset contains indoor measurements of Radon taken throughout the United States. [Radon](https://en.wikipedia.org/wiki/Radon) is naturally ocurring radioactive gas which is [toxic](http://www.radon.com/radon_facts/) in high concentrations.\n\nFor our demonstration, let's suppose we're interested in validating the hypothesis that Radon levels are higher in households containing a basement. We also suspect Radon concentration is related to soil-type, i.e., geography matters.\n\nTo frame this as an ML problem, we'll try to predict log-radon levels based on a linear function of the floor on which the reading was taken. We'll also use the county as a random-effect and in so doing account for variances due to geography. In other words, we'll use a [generalized linear mixed-effect model](https://en.wikipedia.org/wiki/Generalized_linear_mixed_model).\n\n\n```\n%matplotlib inline\n\n\nfrom pprint import pprint\nimport collections\nimport matplotlib.pyplot as plt; plt.style.use('ggplot')\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns; sns.set_context('notebook')\nimport tensorflow.compat.v1 as tf\nimport warnings\n```\n\n### Obtain Dataset:\n\n\n```\nfrom six.moves import urllib\nCACHE_DIR = os.path.join(os.sep, 'tmp', 'radon')\n\ndef cache_or_download_file(cache_dir, url_base, filename):\n \"\"\"Read a cached file or download it.\"\"\"\n filepath = os.path.join(cache_dir, filename)\n if tf.gfile.Exists(filepath):\n return filepath\n if not tf.gfile.Exists(cache_dir):\n tf.gfile.MakeDirs(cache_dir)\n url = os.path.join(url_base, filename)\n print(\"Downloading {url} to {filepath}.\".format(url=url, filepath=filepath))\n urllib.request.urlretrieve(url, filepath)\n return filepath\n\n\ndef download_radon_dataset(cache_dir=CACHE_DIR):\n \"\"\"Download the radon dataset and read as Pandas dataframe.\"\"\"\n url_base = 'http://www.stat.columbia.edu/~gelman/arm/examples/radon/'\n # Alternative source:\n # url_base = ('https://raw.githubusercontent.com/pymc-devs/uq_chapter/'\n # 'master/reference/data/')\n srrs2 = pd.read_csv(cache_or_download_file(cache_dir, url_base, 'srrs2.dat'))\n srrs2.rename(columns=str.strip, inplace=True)\n cty = pd.read_csv(cache_or_download_file(cache_dir, url_base, 'cty.dat'))\n cty.rename(columns=str.strip, inplace=True)\n return srrs2, cty\n\n\ndef preprocess_radon_dataset(srrs2, cty, state='MN'):\n \"\"\"Preprocess radon dataset as done in \"Bayesian Data Analysis\" book.\"\"\"\n srrs2 = srrs2[srrs2.state==state].copy()\n cty = cty[cty.st==state].copy()\n \n # We will now join datasets on Federal Information Processing Standards\n # (FIPS) id, ie, codes that link geographic units, counties and county\n # equivalents. http://jeffgill.org/Teaching/rpqm_9.pdf\n srrs2['fips'] = 1000 * srrs2.stfips + srrs2.cntyfips\n cty['fips'] = 1000 * cty.stfips + cty.ctfips\n\n df = srrs2.merge(cty[['fips', 'Uppm']], on='fips')\n df = df.drop_duplicates(subset='idnum')\n df = df.rename(index=str, columns={'Uppm': 'uranium_ppm'})\n \n df['radon'] = df.activity.apply(lambda x: x if x > 0. else 0.1)\n \n # Remap categories to start from 0 and end at max(category).\n county_name = sorted(df.county.unique())\n df['county'] = df.county.astype(\n pd.api.types.CategoricalDtype(categories=county_name)).cat.codes\n county_name = map(str.strip, county_name)\n \n df['log_radon'] = df['radon'].apply(np.log)\n df['log_uranium_ppm'] = df['uranium_ppm'].apply(np.log) \n df = df[['log_radon', 'floor', 'county', 'log_uranium_ppm']]\n \n return df, county_name\n```\n\n\n```\ndf, counties = preprocess_radon_dataset(*download_radon_dataset())\n```\n\n\n```\ndf.head()\n```\n\n\n\n\n\n View on TensorFlow.org\n \n \n Run in Google Colab\n \n \n View source on GitHub\n \n \n Download notebook\n \n\n \n
\n\n \n \n \n \n log_radon \n floor \n county \n log_uranium_ppm \n \n \n 0 \n 0.788457 \n 1 \n 0 \n -0.689048 \n \n \n 1 \n 0.788457 \n 0 \n 0 \n -0.689048 \n \n \n 2 \n 1.064711 \n 0 \n 0 \n -0.689048 \n \n \n 3 \n 0.000000 \n 0 \n 0 \n -0.689048 \n \n \n \n4 \n 1.131402 \n 0 \n 1 \n -0.847313 \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n date_of_birth \n outcome_type \n outcome_subtype \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n \n \n 0 \n A775354 \n Charley \n 2019-11-12T13:29:00.000 \n 2019-11-12T13:29:00.000 \n 2013-06-28T00:00:00.000 \n Adoption \n NaN \n Dog \n Neutered Male \n 6 years \n Cocker Spaniel Mix \n Black/White \n \n \n 1 \n A775130 \n *Slinky \n 2019-11-12T13:17:00.000 \n 2019-11-12T13:17:00.000 \n 2016-06-25T00:00:00.000 \n Adoption \n Foster \n Dog \n Spayed Female \n 3 years \n Pit Bull Mix \n Blue/White \n \n \n 2 \n A808385 \n NaN \n 2019-11-12T13:16:00.000 \n 2019-11-12T13:16:00.000 \n 2018-11-08T00:00:00.000 \n Transfer \n Partner \n Dog \n Neutered Male \n 1 year \n Pug/Chihuahua Shorthair \n White/Brown \n \n \n 3 \n A799709 \n *Deeogee \n 2019-11-12T13:15:00.000 \n 2019-11-12T13:15:00.000 \n 2018-07-11T00:00:00.000 \n Adoption \n Foster \n Dog \n Neutered Male \n 1 year \n Beagle Mix \n Brown Brindle \n \n \n \n4 \n A713661 \n Coco \n 2019-11-12T12:46:00.000 \n 2019-11-12T12:46:00.000 \n 2013-10-10T00:00:00.000 \n Return to Owner \n NaN \n Dog \n Spayed Female \n 6 years \n Labrador Retriever Mix \n Black/White \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n date_of_birth \n outcome_subtype \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n \n \n 0 \n A775354 \n Charley \n 2019-11-12T13:29:00.000 \n 2019-11-12T13:29:00.000 \n 2013-06-28T00:00:00.000 \n NaN \n Dog \n Neutered Male \n 6 years \n Cocker Spaniel Mix \n Black/White \n Adopted \n \n \n 1 \n A775130 \n *Slinky \n 2019-11-12T13:17:00.000 \n 2019-11-12T13:17:00.000 \n 2016-06-25T00:00:00.000 \n Foster \n Dog \n Spayed Female \n 3 years \n Pit Bull Mix \n Blue/White \n Adopted \n \n \n 2 \n A808385 \n NaN \n 2019-11-12T13:16:00.000 \n 2019-11-12T13:16:00.000 \n 2018-11-08T00:00:00.000 \n Partner \n Dog \n Neutered Male \n 1 year \n Pug/Chihuahua Shorthair \n White/Brown \n Not adopted \n \n \n 3 \n A799709 \n *Deeogee \n 2019-11-12T13:15:00.000 \n 2019-11-12T13:15:00.000 \n 2018-07-11T00:00:00.000 \n Foster \n Dog \n Neutered Male \n 1 year \n Beagle Mix \n Brown Brindle \n Adopted \n \n \n 5 \n A808367 \n Daily \n 2019-11-12T12:38:00.000 \n 2019-11-12T12:38:00.000 \n 2016-11-07T00:00:00.000 \n Partner \n Dog \n Intact Female \n 3 years \n Australian Cattle Dog/Labrador Retriever \n Cream \n Not adopted \n \n \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n ... \n \n \n 99995 \n A679740 \n NaN \n 2014-05-26T16:55:00.000 \n 2014-05-26T16:55:00.000 \n 2014-03-25T00:00:00.000 \n Partner \n Dog \n Intact Male \n 2 months \n Catahoula Mix \n Brown Brindle/White \n Not adopted \n \n \n 99996 \n A679715 \n NaN \n 2014-05-26T16:54:00.000 \n 2014-05-26T16:54:00.000 \n 2014-03-25T00:00:00.000 \n Partner \n Dog \n Intact Female \n 2 months \n Catahoula Mix \n Tan/White \n Not adopted \n \n \n 99997 \n A677532 \n *Taco \n 2014-05-26T16:52:00.000 \n 2014-05-26T16:52:00.000 \n 2014-03-15T00:00:00.000 \n NaN \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair Mix \n White \n Adopted \n \n \n 99998 \n A677530 \n *Chimichanga \n 2014-05-26T16:51:00.000 \n 2014-05-26T16:51:00.000 \n 2014-03-15T00:00:00.000 \n NaN \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair Mix \n Black \n Adopted \n \n \n \n99999 \n A679225 \n Phoebe \n 2014-05-26T16:40:00.000 \n 2014-05-26T16:40:00.000 \n 2011-05-17T00:00:00.000 \n NaN \n Dog \n Spayed Female \n 3 years \n Maltese/Miniature Poodle \n Apricot \n Adopted \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n date_of_birth \n outcome_type \n outcome_subtype \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n \n \n 2565 \n A803963 \n Little Bit \n 2019-09-27 17:59:00 \n 2019-09-27T17:59:00.000 \n 2017-09-09T00:00:00.000 \n NaN \n NaN \n Dog \n Intact Male \n NaN \n Miniature Schnauzer \n Gray/Black \n Adopted \n \n \n 53725 \n A737705 \n *Heddy \n 2016-11-19 16:35:00 \n 2016-11-19T16:35:00.000 \n 2013-11-02T00:00:00.000 \n NaN \n NaN \n Dog \n NaN \n NaN \n Labrador Retriever Mix \n Black/White \n Adopted \n \n \n \n94975 \n A686025 \n NaN \n 2014-08-16 08:35:00 \n 2014-08-16T08:35:00.000 \n 2013-08-15T00:00:00.000 \n NaN \n NaN \n Other \n Unknown \n 1 year \n Bat Mix \n Brown \n Adopted \n \n \n
\n\n \n \n \n \n cluster \n x \n y \n \n \n 0 \n 0 \n 4 \n 10 \n \n \n 1 \n 0 \n 7 \n 10 \n \n \n 2 \n 0 \n 4 \n 8 \n \n \n 3 \n 0 \n 6 \n 8 \n \n \n 4 \n 0 \n 3 \n 4 \n \n \n 5 \n 0 \n 10 \n 5 \n \n \n 6 \n 0 \n 12 \n 6 \n \n \n 7 \n 0 \n 11 \n 4 \n \n \n 8 \n 0 \n 2 \n 2 \n \n \n 9 \n 0 \n 5 \n 2 \n \n \n 10 \n 0 \n 9 \n 3 \n \n \n \n11 \n 0 \n 12 \n 3 \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\nThis is my first markdown try
\nI'll do my best to make it structured
\nLet's test all the headings
\nThree left
\nTwo left
\nAaaaand the last one
\n\n
Awsome!
\n Here is my first bold text.
\n Let's try how italic looks like.
\n Now let's buy some milkshnitte dark chocolate.
\n See this is Emphasized text.
\n Now this is Underline text.
\n Aaaaand this is x2.
\n Aaaaaand this is L1.
\n Now let's try some lists data
\n\n
\n\n
\n \n
\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\nEquation of a line: $$y=ax + b$$\nRoots of the quadric equation $ax^2+bx+c=0$: $$\\begin{array}{*{20}c} {x_{1,2} = \\large{\\frac{{ - b \\pm \\sqrt {b^2 - 4ac} }}{{2a}}}} \\\\ \\end{array}$$\n\nTaylor series expansion: $$f(x)|_{x=a} = f(a) + f^\\prime(a)(x-a)+\\frac{f^n(a)}{2!}(x-a)^2+\\dots+\\frac{f^{(n)}(a)}{n!}(x-a)^n+\\dots$$\nBinominal theorem: $$(x+y)^n=\\binom{n}{0}x^ny^0+\\binom{n}{1}x^{n-1}y^1+\\dots+\\binom{n}{n}x^0y^n=\\sum^n_{k=0}\\binom{n}{k}x^{n-k}y^k$$\nAn integral: $$\\normalsize{\\int^{+\\infty}_{-\\infty}e^{-x^2}dx = \\sqrt {\\pi}}$$\nA short matrix: $$\\begin{pmatrix}\n2 & 1 & 3\\\\\n2 & 6 & 8\\\\\n6 & 8 & 18\n\\end{pmatrix}$$\nA long matrix: $$A = \\begin{pmatrix}\na_{11} & a_{12} & \\dots & a_{1n}\\\\\na_{21} & a_{22} & \\dots & a_{2n}\\\\\n\\vdots & \\vdots & \\ddots & \\vdots\\\\\na_{m1} & a_{m2} & \\dots & a_{mn}\\\\\n\\end{pmatrix}$$\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()\nx = sympy.symbols('x')\na, b, c = sympy.symbols('a b c')\nsympy.solve(a * x**2 + b*x + c)\nsympy.solve(a * x**2 + b*x + c, x)\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\ndef solve_quadratic_equation(a, b, c):\n \"\"\"\n Returns the real solutions of the quadratic equation ax^2 + bx + c = 0\n \"\"\"\n solution_check = b ** 2 - 4 * a * c \n if a != 0:\n if solution_check > 0: \n x1 = (-b + math.sqrt(-4 * a * c + b ** 2)) / (2 * a)\n x2 = -(b + math.sqrt(-4 * a * c + b ** 2)) / (2 * a)\n return [x2, x1]\n elif solution_check == 0: \n x = -b / (2 * a)\n return [x]\n else: \n return []\n else:\n if solution_check > 0: \n x = -(c / b)\n return [x]\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)) # []\nprint(solve_quadratic_equation(0, 2, 3)) # [-1.5]\n```\n\n [-1.0, 2.0]\n [4.0]\n []\n [-1.5]\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(-3, 5, 1000)\ny = 2 * x + 3\nplt.plot(x, y)\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\ndef center_spines(ax, centerx=0, centery=0):\n \"\"\"Centers the axis spines at \n \n Company \n Contact \n Country \n \n \n Alfreds Futterkiste \n Maria Anders \n Germany \n \n \n Centro comercial Moctezuma \n Francisco Chang \n Mexico \n \n \n Ernst Handel \n Roland Mendel \n Austria \n \n \n Island Trading \n Helen Bennett \n UK \n \n \n Laughing Bacchus Winecellars \n Yoshi Tannamuri \n Canada \n \n \nMagazzini Alimentari Riuniti \n Giovanni Rovelli \n Italy \n
\n\n\n \n \n prepared by Abuzer Yakaryilmaz (QLatvia) and \n
Maksim Dimitrijev(QLatvia) \n
\n$\\newcommand{\\bra}[1]{\\langle #1|}$\n$ \\newcommand{\\ket}[1]{|#1\\rangle} $\n$ \\newcommand{\\braket}[2]{\\langle #1|#2\\rangle} $\n$ \\newcommand{\\dot}[2]{ #1 \\cdot #2} $\n$ \\newcommand{\\biginner}[2]{\\left\\langle #1,#2\\right\\rangle} $\n$ \\newcommand{\\mymatrix}[2]{\\left( \\begin{array}{#1} #2\\end{array} \\right)} $\n$ \\newcommand{\\myvector}[1]{\\mymatrix{c}{#1}} $\n$ \\newcommand{\\myrvector}[1]{\\mymatrix{r}{#1}} $\n$ \\newcommand{\\mypar}[1]{\\left( #1 \\right)} $\n$ \\newcommand{\\mybigpar}[1]{ \\Big( #1 \\Big)} $\n$ \\newcommand{\\sqrttwo}{\\frac{1}{\\sqrt{2}}} $\n$ \\newcommand{\\dsqrttwo}{\\dfrac{1}{\\sqrt{2}}} $\n$ \\newcommand{\\onehalf}{\\frac{1}{2}} $\n$ \\newcommand{\\donehalf}{\\dfrac{1}{2}} $\n$ \\newcommand{\\hadamard}{ \\mymatrix{rr}{ \\sqrttwo & \\sqrttwo \\\\ \\sqrttwo & -\\sqrttwo }} $\n$ \\newcommand{\\vzero}{\\myvector{1\\\\0}} $\n$ \\newcommand{\\vone}{\\myvector{0\\\\1}} $\n$ \\newcommand{\\vhadamardzero}{\\myvector{ \\sqrttwo \\\\ \\sqrttwo } } $\n$ \\newcommand{\\vhadamardone}{ \\myrvector{ \\sqrttwo \\\\ -\\sqrttwo } } $\n$ \\newcommand{\\myarray}[2]{ \\begin{array}{#1}#2\\end{array}} $\n$ \\newcommand{\\X}{ \\mymatrix{cc}{0 & 1 \\\\ 1 & 0} } $\n$ \\newcommand{\\Z}{ \\mymatrix{rr}{1 & 0 \\\\ 0 & -1} } $\n$ \\newcommand{\\Htwo}{ \\mymatrix{rrrr}{ \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} & \\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} \\\\ \\frac{1}{2} & -\\frac{1}{2} & -\\frac{1}{2} & \\frac{1}{2} } } $\n$ \\newcommand{\\CNOT}{ \\mymatrix{cccc}{1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\ 0 & 0 & 1 & 0} } $\n$ \\newcommand{\\norm}[1]{ \\left\\lVert #1 \\right\\rVert } $\n$ \\newcommand{\\pstate}[1]{ \\lceil \\mspace{-1mu} #1 \\mspace{-1.5mu} \\rfloor } $\n\n# Qiskit, Qutip installation and test\n\n\nThis cell contains some macros. If there is a problem with displaying mathematical formulas, please run this cell to load these macros.
\n\n## Install Qiskit\n\nYou can install Qiskit by executing the following cell.\n\n\n```python\n!pip install \"qiskit[visualization]\" --user\n```\n\n Requirement already satisfied: qiskit[visualization] in /home/dev/.local/lib/python3.8/site-packages (0.28.0)\n Requirement already satisfied: qiskit-ignis==0.6.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (0.6.0)\n Requirement already satisfied: qiskit-terra==0.18.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (0.18.0)\n Requirement already satisfied: qiskit-ibmq-provider==0.15.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (0.15.0)\n Requirement already satisfied: qiskit-aqua==0.9.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (0.9.4)\n Requirement already satisfied: qiskit-aer==0.8.2 in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (0.8.2)\n Requirement already satisfied: ipywidgets>=7.3.0; extra == \"visualization\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (7.6.3)\n Requirement already satisfied: pylatexenc>=1.4; extra == \"visualization\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (2.10)\n Requirement already satisfied: pydot; extra == \"visualization\" in /usr/lib/python3/dist-packages (from qiskit[visualization]) (1.4.1)\n Requirement already satisfied: pillow>=4.2.1; extra == \"visualization\" in /usr/lib/python3/dist-packages (from qiskit[visualization]) (7.0.0)\n Requirement already satisfied: matplotlib>=2.1; extra == \"visualization\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (3.4.2)\n Requirement already satisfied: seaborn>=0.9.0; extra == \"visualization\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (0.11.1)\n Requirement already satisfied: pygments>=2.4; extra == \"visualization\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit[visualization]) (2.9.0)\n Requirement already satisfied: numpy>=1.13 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ignis==0.6.0->qiskit[visualization]) (1.21.0)\n Requirement already satisfied: setuptools>=40.1.0 in /usr/lib/python3/dist-packages (from qiskit-ignis==0.6.0->qiskit[visualization]) (45.2.0)\n Requirement already satisfied: retworkx>=0.8.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ignis==0.6.0->qiskit[visualization]) (0.9.0)\n Requirement already satisfied: scipy!=0.19.1,>=0.19 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ignis==0.6.0->qiskit[visualization]) (1.7.0)\n Requirement already satisfied: ply>=3.10 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (3.11)\n Requirement already satisfied: fastjsonschema>=2.10 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (2.15.1)\n Requirement already satisfied: tweedledum<2.0,>=1.1 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (1.1.0)\n Requirement already satisfied: sympy>=1.3 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (1.8)\n Requirement already satisfied: psutil>=5 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (5.8.0)\n Requirement already satisfied: python-dateutil>=2.8.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (2.8.2)\n Requirement already satisfied: jsonschema>=2.6 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (3.2.0)\n Requirement already satisfied: python-constraint>=1.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (1.4.0)\n Requirement already satisfied: symengine>0.7; platform_machine == \"x86_64\" or platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"amd64\" or platform_machine == \"arm64\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (0.7.2)\n Requirement already satisfied: dill>=0.3 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit[visualization]) (0.3.4)\n Requirement already satisfied: websocket-client>=1.0.1 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ibmq-provider==0.15.0->qiskit[visualization]) (1.1.0)\n Requirement already satisfied: requests-ntlm>=1.1.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ibmq-provider==0.15.0->qiskit[visualization]) (1.1.0)\n Requirement already satisfied: requests>=2.19 in /usr/lib/python3/dist-packages (from qiskit-ibmq-provider==0.15.0->qiskit[visualization]) (2.22.0)\n Requirement already satisfied: urllib3>=1.21.1 in /usr/lib/python3/dist-packages (from qiskit-ibmq-provider==0.15.0->qiskit[visualization]) (1.25.8)\n Requirement already satisfied: scikit-learn>=0.20.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (0.24.2)\n Requirement already satisfied: h5py<3.3.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (3.2.1)\n Requirement already satisfied: yfinance<0.1.63 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (0.1.62)\n Requirement already satisfied: dlx<=1.0.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (1.0.4)\n Requirement already satisfied: docplex>=2.21.207 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (2.21.207)\n Requirement already satisfied: pandas in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (1.3.0)\n Requirement already satisfied: fastdtw<=0.3.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (0.3.4)\n Requirement already satisfied: quandl in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit[visualization]) (3.6.1)\n Requirement already satisfied: pybind11>=2.6 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aer==0.8.2->qiskit[visualization]) (2.7.0)\n Requirement already satisfied: ipython>=4.0.0; python_version >= \"3.3\" in /home/dev/.local/lib/python3.8/site-packages (from ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (7.25.0)\n Requirement already satisfied: traitlets>=4.3.1 in /home/dev/.local/lib/python3.8/site-packages (from ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (5.0.5)\n Requirement already satisfied: nbformat>=4.2.0 in /home/dev/.local/lib/python3.8/site-packages (from ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (5.1.3)\n Requirement already satisfied: jupyterlab-widgets>=1.0.0; python_version >= \"3.6\" in /home/dev/.local/lib/python3.8/site-packages (from ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.0.0)\n Requirement already satisfied: widgetsnbextension~=3.5.0 in /home/dev/.local/lib/python3.8/site-packages (from ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (3.5.1)\n Requirement already satisfied: ipykernel>=4.5.1 in /home/dev/.local/lib/python3.8/site-packages (from ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (6.0.1)\n Requirement already satisfied: cycler>=0.10 in /home/dev/.local/lib/python3.8/site-packages (from matplotlib>=2.1; extra == \"visualization\"->qiskit[visualization]) (0.10.0)\n Requirement already satisfied: pyparsing>=2.2.1 in /home/dev/.local/lib/python3.8/site-packages (from matplotlib>=2.1; extra == \"visualization\"->qiskit[visualization]) (2.4.7)\n Requirement already satisfied: kiwisolver>=1.0.1 in /home/dev/.local/lib/python3.8/site-packages (from matplotlib>=2.1; extra == \"visualization\"->qiskit[visualization]) (1.3.1)\n Requirement already satisfied: mpmath>=0.19 in /home/dev/.local/lib/python3.8/site-packages (from sympy>=1.3->qiskit-terra==0.18.0->qiskit[visualization]) (1.2.1)\n Requirement already satisfied: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.8.0->qiskit-terra==0.18.0->qiskit[visualization]) (1.14.0)\n Requirement already satisfied: pyrsistent>=0.14.0 in /home/dev/.local/lib/python3.8/site-packages (from jsonschema>=2.6->qiskit-terra==0.18.0->qiskit[visualization]) (0.18.0)\n Requirement already satisfied: attrs>=17.4.0 in /home/dev/.local/lib/python3.8/site-packages (from jsonschema>=2.6->qiskit-terra==0.18.0->qiskit[visualization]) (21.2.0)\n Requirement already satisfied: ntlm-auth>=1.0.2 in /home/dev/.local/lib/python3.8/site-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.15.0->qiskit[visualization]) (1.5.0)\n Requirement already satisfied: cryptography>=1.3 in /usr/lib/python3/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.15.0->qiskit[visualization]) (2.8)\n Requirement already satisfied: threadpoolctl>=2.0.0 in /home/dev/.local/lib/python3.8/site-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.4->qiskit[visualization]) (2.2.0)\n Requirement already satisfied: joblib>=0.11 in /home/dev/.local/lib/python3.8/site-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.4->qiskit[visualization]) (1.0.1)\n Requirement already satisfied: lxml>=4.5.1 in /home/dev/.local/lib/python3.8/site-packages (from yfinance<0.1.63->qiskit-aqua==0.9.4->qiskit[visualization]) (4.6.3)\n Requirement already satisfied: multitasking>=0.0.7 in /home/dev/.local/lib/python3.8/site-packages (from yfinance<0.1.63->qiskit-aqua==0.9.4->qiskit[visualization]) (0.0.9)\n Requirement already satisfied: pytz>=2017.3 in /usr/lib/python3/dist-packages (from pandas->qiskit-aqua==0.9.4->qiskit[visualization]) (2019.3)\n Requirement already satisfied: more-itertools in /home/dev/.local/lib/python3.8/site-packages (from quandl->qiskit-aqua==0.9.4->qiskit[visualization]) (8.8.0)\n Requirement already satisfied: inflection>=0.3.1 in /home/dev/.local/lib/python3.8/site-packages (from quandl->qiskit-aqua==0.9.4->qiskit[visualization]) (0.5.1)\n Requirement already satisfied: pickleshare in /home/dev/.local/lib/python3.8/site-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.7.5)\n Requirement already satisfied: prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0 in /home/dev/.local/lib/python3.8/site-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (3.0.19)\n Requirement already satisfied: backcall in /home/dev/.local/lib/python3.8/site-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.2.0)\n Requirement already satisfied: jedi>=0.16 in /home/dev/.local/lib/python3.8/site-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.18.0)\n Requirement already satisfied: decorator in /home/dev/.local/lib/python3.8/site-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (4.4.2)\n Requirement already satisfied: matplotlib-inline in /home/dev/.local/lib/python3.8/site-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.1.2)\n Requirement already satisfied: pexpect>4.3; sys_platform != \"win32\" in /usr/lib/python3/dist-packages (from ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (4.6.0)\n Requirement already satisfied: ipython-genutils in /home/dev/.local/lib/python3.8/site-packages (from traitlets>=4.3.1->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.2.0)\n Requirement already satisfied: jupyter-core in /home/dev/.local/lib/python3.8/site-packages (from nbformat>=4.2.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (4.7.1)\n Requirement already satisfied: notebook>=4.4.1 in /home/dev/.local/lib/python3.8/site-packages (from widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (6.4.0)\n Requirement already satisfied: tornado>=4.2 in /home/dev/.local/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (6.1)\n Requirement already satisfied: debugpy>=1.0.0 in /home/dev/.local/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.3.0)\n Requirement already satisfied: jupyter-client in /home/dev/.local/lib/python3.8/site-packages (from ipykernel>=4.5.1->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (6.1.12)\n Requirement already satisfied: wcwidth in /home/dev/.local/lib/python3.8/site-packages (from prompt-toolkit!=3.0.0,!=3.0.1,<3.1.0,>=2.0.0->ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.2.5)\n Requirement already satisfied: parso<0.9.0,>=0.8.0 in /home/dev/.local/lib/python3.8/site-packages (from jedi>=0.16->ipython>=4.0.0; python_version >= \"3.3\"->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.8.2)\n Requirement already satisfied: jinja2 in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (3.0.1)\n Requirement already satisfied: nbconvert in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (6.1.0)\n Requirement already satisfied: terminado>=0.8.3 in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.10.1)\n Requirement already satisfied: prometheus-client in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.11.0)\n Requirement already satisfied: pyzmq>=17 in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (22.1.0)\n Requirement already satisfied: argon2-cffi in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (20.1.0)\n Requirement already satisfied: Send2Trash>=1.5.0 in /home/dev/.local/lib/python3.8/site-packages (from notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.7.1)\n Requirement already satisfied: MarkupSafe>=2.0 in /home/dev/.local/lib/python3.8/site-packages (from jinja2->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (2.0.1)\n Requirement already satisfied: mistune<2,>=0.8.1 in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.8.4)\n Requirement already satisfied: entrypoints>=0.2.2 in /usr/lib/python3/dist-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.3)\n Requirement already satisfied: bleach in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (3.3.0)\n Requirement already satisfied: defusedxml in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.7.1)\n Requirement already satisfied: jupyterlab-pygments in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.1.2)\n Requirement already satisfied: nbclient<0.6.0,>=0.5.0 in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.5.3)\n Requirement already satisfied: testpath in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.5.0)\n Requirement already satisfied: pandocfilters>=1.4.1 in /home/dev/.local/lib/python3.8/site-packages (from nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.4.3)\n Requirement already satisfied: ptyprocess; os_name != \"nt\" in /home/dev/.local/lib/python3.8/site-packages (from terminado>=0.8.3->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.7.0)\n Requirement already satisfied: cffi>=1.0.0 in /home/dev/.local/lib/python3.8/site-packages (from argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.14.6)\n Requirement already satisfied: packaging in /home/dev/.local/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (21.0)\n Requirement already satisfied: webencodings in /home/dev/.local/lib/python3.8/site-packages (from bleach->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (0.5.1)\n Requirement already satisfied: async-generator in /home/dev/.local/lib/python3.8/site-packages (from nbclient<0.6.0,>=0.5.0->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.10)\n Requirement already satisfied: nest-asyncio in /home/dev/.local/lib/python3.8/site-packages (from nbclient<0.6.0,>=0.5.0->nbconvert->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (1.5.1)\n Requirement already satisfied: pycparser in /home/dev/.local/lib/python3.8/site-packages (from cffi>=1.0.0->argon2-cffi->notebook>=4.4.1->widgetsnbextension~=3.5.0->ipywidgets>=7.3.0; extra == \"visualization\"->qiskit[visualization]) (2.20)\n\n\n__*Restart the kernel*__ (check \"Kernel\" menu) to apply the changes to the current notebook.\n\nYou may also visit the following links for further information.\n\n- https://github.com/Qiskit/qiskit-tutorials/blob/master/INSTALL.md\n\n- https://pypi.org/project/qiskit/0.15.0/\n\n__*Restart the kernel*__ (check \"Kernel\" menu) to apply the changes to the current notebook.\n\n
\n\n### Tips\n\n_Any terminal/shell command can be executed in the notebook cells by putting exclamation mark (!) to the beginning of the command._\n\n_$\\rightarrow$ For updating Qiskit version, execute the following command on a code cell_\n\n !pip install -U qiskit --user\n \n_$\\rightarrow$ For uninstall Qiskit, execute the following command on a code cell_\n\n !pip uninstall qiskit\n\n\n```python\n!pip install -U qiskit --user\n#!pip uninstall qiskit\n```\n\n Requirement already up-to-date: qiskit in /home/dev/.local/lib/python3.8/site-packages (0.28.0)\n Requirement already satisfied, skipping upgrade: qiskit-ignis==0.6.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit) (0.6.0)\n Requirement already satisfied, skipping upgrade: qiskit-ibmq-provider==0.15.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit) (0.15.0)\n Requirement already satisfied, skipping upgrade: qiskit-aqua==0.9.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit) (0.9.4)\n Requirement already satisfied, skipping upgrade: qiskit-terra==0.18.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit) (0.18.0)\n Requirement already satisfied, skipping upgrade: qiskit-aer==0.8.2 in /home/dev/.local/lib/python3.8/site-packages (from qiskit) (0.8.2)\n Requirement already satisfied, skipping upgrade: scipy!=0.19.1,>=0.19 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ignis==0.6.0->qiskit) (1.7.0)\n Requirement already satisfied, skipping upgrade: numpy>=1.13 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ignis==0.6.0->qiskit) (1.21.0)\n Requirement already satisfied, skipping upgrade: retworkx>=0.8.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ignis==0.6.0->qiskit) (0.9.0)\n Requirement already satisfied, skipping upgrade: setuptools>=40.1.0 in /usr/lib/python3/dist-packages (from qiskit-ignis==0.6.0->qiskit) (45.2.0)\n Requirement already satisfied, skipping upgrade: websocket-client>=1.0.1 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ibmq-provider==0.15.0->qiskit) (1.1.0)\n Requirement already satisfied, skipping upgrade: requests-ntlm>=1.1.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ibmq-provider==0.15.0->qiskit) (1.1.0)\n Requirement already satisfied, skipping upgrade: python-dateutil>=2.8.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-ibmq-provider==0.15.0->qiskit) (2.8.2)\n Requirement already satisfied, skipping upgrade: requests>=2.19 in /usr/lib/python3/dist-packages (from qiskit-ibmq-provider==0.15.0->qiskit) (2.22.0)\n Requirement already satisfied, skipping upgrade: urllib3>=1.21.1 in /usr/lib/python3/dist-packages (from qiskit-ibmq-provider==0.15.0->qiskit) (1.25.8)\n Requirement already satisfied, skipping upgrade: pandas in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (1.3.0)\n Requirement already satisfied, skipping upgrade: quandl in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (3.6.1)\n Requirement already satisfied, skipping upgrade: docplex>=2.21.207 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (2.21.207)\n Requirement already satisfied, skipping upgrade: yfinance<0.1.63 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (0.1.62)\n Requirement already satisfied, skipping upgrade: dlx<=1.0.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (1.0.4)\n Requirement already satisfied, skipping upgrade: h5py<3.3.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (3.2.1)\n Requirement already satisfied, skipping upgrade: fastdtw<=0.3.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (0.3.4)\n Requirement already satisfied, skipping upgrade: psutil>=5 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (5.8.0)\n Requirement already satisfied, skipping upgrade: sympy>=1.3 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (1.8)\n Requirement already satisfied, skipping upgrade: scikit-learn>=0.20.0 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aqua==0.9.4->qiskit) (0.24.2)\n Requirement already satisfied, skipping upgrade: tweedledum<2.0,>=1.1 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (1.1.0)\n Requirement already satisfied, skipping upgrade: ply>=3.10 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (3.11)\n Requirement already satisfied, skipping upgrade: jsonschema>=2.6 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (3.2.0)\n Requirement already satisfied, skipping upgrade: python-constraint>=1.4 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (1.4.0)\n Requirement already satisfied, skipping upgrade: fastjsonschema>=2.10 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (2.15.1)\n Requirement already satisfied, skipping upgrade: symengine>0.7; platform_machine == \"x86_64\" or platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"amd64\" or platform_machine == \"arm64\" in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (0.7.2)\n Requirement already satisfied, skipping upgrade: dill>=0.3 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-terra==0.18.0->qiskit) (0.3.4)\n Requirement already satisfied, skipping upgrade: pybind11>=2.6 in /home/dev/.local/lib/python3.8/site-packages (from qiskit-aer==0.8.2->qiskit) (2.7.0)\n Requirement already satisfied, skipping upgrade: cryptography>=1.3 in /usr/lib/python3/dist-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.15.0->qiskit) (2.8)\n Requirement already satisfied, skipping upgrade: ntlm-auth>=1.0.2 in /home/dev/.local/lib/python3.8/site-packages (from requests-ntlm>=1.1.0->qiskit-ibmq-provider==0.15.0->qiskit) (1.5.0)\n Requirement already satisfied, skipping upgrade: six>=1.5 in /usr/lib/python3/dist-packages (from python-dateutil>=2.8.0->qiskit-ibmq-provider==0.15.0->qiskit) (1.14.0)\n Requirement already satisfied, skipping upgrade: pytz>=2017.3 in /usr/lib/python3/dist-packages (from pandas->qiskit-aqua==0.9.4->qiskit) (2019.3)\n Requirement already satisfied, skipping upgrade: more-itertools in /home/dev/.local/lib/python3.8/site-packages (from quandl->qiskit-aqua==0.9.4->qiskit) (8.8.0)\n Requirement already satisfied, skipping upgrade: inflection>=0.3.1 in /home/dev/.local/lib/python3.8/site-packages (from quandl->qiskit-aqua==0.9.4->qiskit) (0.5.1)\n Requirement already satisfied, skipping upgrade: lxml>=4.5.1 in /home/dev/.local/lib/python3.8/site-packages (from yfinance<0.1.63->qiskit-aqua==0.9.4->qiskit) (4.6.3)\n Requirement already satisfied, skipping upgrade: multitasking>=0.0.7 in /home/dev/.local/lib/python3.8/site-packages (from yfinance<0.1.63->qiskit-aqua==0.9.4->qiskit) (0.0.9)\n Requirement already satisfied, skipping upgrade: mpmath>=0.19 in /home/dev/.local/lib/python3.8/site-packages (from sympy>=1.3->qiskit-aqua==0.9.4->qiskit) (1.2.1)\n Requirement already satisfied, skipping upgrade: joblib>=0.11 in /home/dev/.local/lib/python3.8/site-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.4->qiskit) (1.0.1)\n Requirement already satisfied, skipping upgrade: threadpoolctl>=2.0.0 in /home/dev/.local/lib/python3.8/site-packages (from scikit-learn>=0.20.0->qiskit-aqua==0.9.4->qiskit) (2.2.0)\n Requirement already satisfied, skipping upgrade: attrs>=17.4.0 in /home/dev/.local/lib/python3.8/site-packages (from jsonschema>=2.6->qiskit-terra==0.18.0->qiskit) (21.2.0)\n Requirement already satisfied, skipping upgrade: pyrsistent>=0.14.0 in /home/dev/.local/lib/python3.8/site-packages (from jsonschema>=2.6->qiskit-terra==0.18.0->qiskit) (0.18.0)\n\n\n
\n\n## Install QuTiP\n\nType\n\n !pip install qutip\n \ndirectly inside the cell of a Jupyter notebook.\n \nFor a workaround without pip you may execute the following commands in the Anaconda terminal:\n\n
\n\n\n```python\n!pip install qutip\n```\n\n Requirement already satisfied: qutip in /home/dev/.local/lib/python3.8/site-packages (4.6.2)\n Requirement already satisfied: scipy>=1.0 in /home/dev/.local/lib/python3.8/site-packages (from qutip) (1.7.0)\n Requirement already satisfied: packaging in /home/dev/.local/lib/python3.8/site-packages (from qutip) (21.0)\n Requirement already satisfied: numpy>=1.16.6 in /home/dev/.local/lib/python3.8/site-packages (from qutip) (1.21.0)\n Requirement already satisfied: pyparsing>=2.0.2 in /home/dev/.local/lib/python3.8/site-packages (from packaging->qutip) (2.4.7)\n\n\n
\n\n## Check Qiskit installation\n\n\n\n\n```python\nimport qiskit\nversions = qiskit.__qiskit_version__\nprint(\"The version of Qiskit is\",versions['qiskit'])\nprint()\nprint(\"The version of each component:\")\nfor key in versions:\n print(key,\"->\",versions[key])\n```\n\n The version of Qiskit is 0.28.0\n \n The version of each component:\n qiskit-terra -> 0.18.0\n qiskit-aer -> 0.8.2\n qiskit-ignis -> 0.6.0\n qiskit-ibmq-provider -> 0.15.0\n qiskit-aqua -> 0.9.4\n qiskit -> 0.28.0\n qiskit-nature -> None\n qiskit-finance -> None\n qiskit-optimization -> None\n qiskit-machine-learning -> None\n\n\n /home/dev/.local/lib/python3.8/site-packages/qiskit/aqua/__init__.py:86: DeprecationWarning: The package qiskit.aqua is deprecated. It was moved/refactored to qiskit-terra For more information see
\n\n## Execute an example program\n\n\n1) Create a quantum circuit\n\n\n```python\n# import the objects from qiskit\nfrom qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer\nfrom random import randrange\n\n# create a quantum circuit and its register objects\nqreg = QuantumRegister(2) # quantum register with two quantum bits\ncreg = ClassicalRegister(2) # classical register with two classical bits\ncircuit = QuantumCircuit(qreg,creg) # quantum circuit composed by a quantum register and a classical register\n\n# apply a Hadamard gate to the first qubit\ncircuit.h(qreg[0])\n\n# set the second qubit to state |1>\ncircuit.x(qreg[1])\n\n# apply CNOT(first_qubit,second_qubit)\ncircuit.cx(qreg[0],qreg[1])\n\n# measure the both qubits\ncircuit.measure(qreg,creg)\n\nprint(\"The execution of the cell was completed, and the circuit was created :)\")\n```\n\n The execution of the cell was completed, and the circuit was created :)\n\n\n2) Draw the circuit\n\n_Run the cell once more if the figure is not shown_\n\n\n```python\n# draw circuit \ncircuit.draw(output='mpl')\n\n# the output will be a \"matplotlib.Figure\" object\n```\n\n3) Execute the circuit 1024 times in the local simulator and print the observed the outcomes\n\n\n```python\n## execute the circuit 1024 times\njob = execute(circuit,Aer.get_backend('qasm_simulator'),shots=1024)\n# get the result\ncounts = job.result().get_counts(circuit)\nprint(counts)\n```\n\n {'10': 510, '01': 514}\n\n\n4) Check QuTiP - draw a Bloch sphere\n\n\n```python\nfrom qiskit.visualization import plot_bloch_vector, bloch\nfrom matplotlib.pyplot import text\nfrom math import pi, cos, sin\nfrom qutip import *\n\ntheta = pi/2\nphi = 4*pi/3\n\nx = sin(theta)*cos(phi)\ny = sin(theta)*sin(phi)\nz = cos(theta)\n\nsphere = bloch\nsphere.Bloch\nb = Bloch()\nb.ylpos = [1.1, -1.2]\nb.xlabel = ['$\\\\left|0\\\\right>+\\\\left|1\\\\right>$', '$\\\\left|0\\\\right>-\\\\left|1\\\\right>$']\nb.ylabel = ['$\\\\left|0\\\\right>+i\\\\left|1\\\\right>$', '$\\\\left|0\\\\right>-i\\\\left|1\\\\right>$']\nb.vector_color = ['b','b','b','b','b','b','r']\nb.add_vectors([[0,0,1],[0,0,-1],[0,1,0],[0,-1,0],[1,0,0],[-1,0,0]])\nb.add_vectors([x,y,z])\nb.show()\n\n# re-execute this cell if you DO NOT see the Bloch sphere\n```\n\n## Successfully Installed \n\n\n```python\n\n```\n", "meta": {"hexsha": "095ccb4c87ce81c96a1dc34e4bd88eb5c73603c5", "size": 154778, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "test/Qiskit_QuTiP_installation_and_test.ipynb", "max_stars_repo_name": "dev-aditya/QWorld_Summer_School_2021", "max_stars_repo_head_hexsha": "1b8711327845617ca8dc32ff2a20f461d0ee01c7", "max_stars_repo_licenses": ["Apache-2.0", "CC-BY-4.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-08-15T10:57:16.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-15T10:57:16.000Z", "max_issues_repo_path": "test/Qiskit_QuTiP_installation_and_test.ipynb", "max_issues_repo_name": "dev-aditya/QWorld_Summer_School_2021", "max_issues_repo_head_hexsha": "1b8711327845617ca8dc32ff2a20f461d0ee01c7", "max_issues_repo_licenses": ["Apache-2.0", "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": "test/Qiskit_QuTiP_installation_and_test.ipynb", "max_forks_repo_name": "dev-aditya/QWorld_Summer_School_2021", "max_forks_repo_head_hexsha": "1b8711327845617ca8dc32ff2a20f461d0ee01c7", "max_forks_repo_licenses": ["Apache-2.0", "CC-BY-4.0"], "max_forks_count": 3, "max_forks_repo_forks_event_min_datetime": "2021-08-11T11:12:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-14T09:15:08.000Z", "avg_line_length": 257.1063122924, "max_line_length": 97112, "alphanum_fraction": 0.8826060551, "converted": true, "num_tokens": 11132, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.480478678047907, "lm_q2_score": 0.16451646494473968, "lm_q1q2_score": 0.07904665359376335}}
{"text": "\n\n\n```python\n### Running in Google Colab? You'll want to uncomment and run these cell once each time you start this notebook.\n\n\"\"\"\n!wget https://raw.githubusercontent.com/psheehan/CIERA-HS-Program/master/Projects/SGRB-AfterglowModeling/t90.txt\n!wget https://raw.githubusercontent.com/psheehan/CIERA-HS-Program/master/Projects/SGRB-AfterglowModeling/090510_OmuJy.txt\n!wget https://raw.githubusercontent.com/psheehan/CIERA-HS-Program/master/Projects/SGRB-AfterglowModeling/130603b_OmuJy.txt\n!wget https://github.com/psheehan/CIERA-HS-Program/blob/master/Projects/SGRB-AfterglowModeling/multiwave_OmuJy.txt\n\"\"\"\n```\n\n# Short Gamma-Ray Burst Afterglow Fitting\n\n\n```python\n# Loading some packages to get us started\n\n%load_ext autoreload\n%autoreload 2\n%matplotlib inline\n%config InlineBackend.figure_format='retina'\n\nfrom IPython.display import Image\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport astropy.io.ascii as ascii\nfrom astropy import cosmology\nfrom astropy import units as u\nfrom astropy.cosmology import FlatLambdaCDM\n\ncosmo = FlatLambdaCDM(H0=70 * u.km / u.s / u.Mpc, Tcmb0=2.725 * u.K, Om0=0.3)\n```\n\n# Introduction\n\n---\n\n\n\n## Gamma-Rays\n\nConsider the electromagnetic spectrum:\n\n\n\nOn the far right end of the spectrum, we see radio waves. Radio waves are at the lowest energy end of the spectrum. As we move across the spectrum to the left, we increase in energy and frequency. Visible light appears near the middle of the spectrum. Gamma-rays are the highest energy class of light and are only produced on Earth by high energy processes like fusion or gamma decay.\n\n---\n\n\n\n## Gamma-Ray Bursts\n\nIn the 1960s, astronomers started detecting bursts of gamma-ray emission. The high energy flashes did not repeat and were randomly scattered across the sky. After much work, astronomers realized that these bursts of gamma-rays were coming from other galaxies. To produce the high energy $\\textbf{photons}$ (packets of light) that make up gamma-ray bursts (GRBs) a source with a lot of energy is needed! All of these clues led astronomers to believe that are the result of explosions in our universe.\n\nGRBs are not $\\textbf{isotropic}$ (spherically symmetric). In fact, much of the explosion's energy is focused along the two poles. The beam that the gamma-rays are accelerated along is referred to as the $\\textbf{jet}$. The structure of the explosion means that in order to detect a GRB we must be directly in the path of the GRB.\n\n\n\n# Exercise 1\n\n## Short vs. Long Gamma-Ray Bursts (GRBs)\n\nIt became clear that there were two populations of GRBs - those with short durations and long durations. Below, we will plot the durations of GRBs discovered by the space telescope $\\textit{Swift}$ from January 2004 to January 2020. Your job is to run the two cells below, examine the plot and choose a cutoff between short and long duration GRBs.\n\n\n```python\n# data file includes a list of GRBs and the duration of the burst, T90\nswift_cat = ascii.read('t90.txt')\n\n# T90 is the amount of time for 90% of the burst's light to be absorbed\nt90 = swift_cat['T90']\n\n# If you print the list of GRB names, you'll see that each GRB is named by the date\n# it was detected on.\ngrb_name = swift_cat['GRBname']\n```\n\n\n```python\nb=np.logspace(-1,3,40)\nplt.hist(t90,b,color='xkcd:lilac')\nplt.loglog()\nplt.tick_params(direction = 'in', length = 10, labelsize = 16, right = True)\nplt.tick_params(which = 'minor', direction = 'in', length = 6, right = True)\nplt.xlabel('Time (seconds)')\nplt.ylabel('Count')\nplt.title('Histogram of Burst Duration')\nplt.show()\n```\n\n#### Question 1: Looking at the plot, are you convinced that there are two distinct populations of GRBs? Why?\n\nAnswer: \n\n#### How many seconds would you choose as a cutoff between short and long GRBs? Keep in mind that the axes are in 'log' units.\n\nAnswer:\n\nIn reality, we use a few other parameters to classify GRBs as short or long. However, duration of the burst is still a useful tool to classify GRBs.\n\nFor this project, we will be focusing on short gamma-ray bursts.\n\n## Gamma-Ray Burst Afterglows\n\nAccompanying each GRB is a multiwavelength afterglow. Afterglows as produced by fast-moving ejecta from the explosion colliding with gas that exists in the space between stars. The relativistic (aka VERY fast) collisions between the ejecta and the gas produce what is called $\\textbf{synchrotron emission}$. Though we won't go into the mechanics of synchrotron emission here, it's important to know that it creates a $\\textbf{jetted multiwavelength afterglow}$. Below is a diagram of an top hat afterglow. In the far right part of the diagram, you see the explosion (jet) colliding with the gas (ambient medium) to produce an afterglow.\n\n\n\nStudying observations of GRB afterglows can teach us about the properties of the burst, including how dense the environment around the explosion is. Below are answers to questions you may have as you simulate afterglow lightcurves.\n\n#### 1. What does multiwavelength mean?\nMultiwavelength means that light is emitted in more than one part of the electromagnetic spectrum (see the first figure!). An afterglow emits in the radio, the visible (hereafter called \"optical\") and the X-ray.\n\nIdentifying the multiwavelength components of the afterglow is important because our X-ray, optical and radio detectors are better at localizing sources than gamma-ray detectors. A better localization allows astronomers to study the host environment of the burst and build a better understanding of what precipitated the explosion.\n\n#### 2. What is a lightcurve?\nA lightcurve is a plot of time (x-axis) vs brightness (y-axis). Lightcurves are a ubiquitous tool for studying time-domain astronomy. A lightcurve shows us if a source dims, brightens, or stays the same over time. For a steady source like a galaxy, a lightcurve will be flat. A supernova's lightcurve will rise quickly and then fall over time. The lightcurve of a variable star (a star which brightens and dims periodically) will look like this:\n\n\n\nShort GRB afterglow lightcurves are most like supernova lightcurves.\n\n#### 3. What is a jet and why is it important?\n\nA jet is a collimated source of relativistic emission. Among other things, a jet is characterized by it's opening angle and shape.\n\nBoth the shape and the opening angle of the jet determine if the afterglow will be detectable to an $\\textbf{off-axis}$ (not directly in the path of the jet) observer.\n\n#### 4. What does an afterglow jet look like?\n\nGood question! The short answer is that astronomers don't know for sure yet but have many theories. The simulations we'll be using below allow the user to try out a few different jet shapes. These jet shapes include:\n\n$\\textbf{Top Hat Jet}$: flux concentrated equally across a narrow beam, outside of which no flux escapes.\n\n$\\textbf{Gaussian Jet}$: Similar to a top hat jet except a greater amount of flux is concentrated in the center of the beam.\n\n$\\textbf{Power Law Jet}$: Flux concentrated in the middle of the jet but decays as you move to larger viewing angles.\n\n\n## Using $\\texttt{afterglowpy}$\n\nWe'll be using the Python package $\\texttt{afterglowpy}$ (Ryan et al. 2015, Ryan et al. 2019) to simulate multiwavelength afterglow (AG) lightcurves and match them to actual observations.\n\nFrom https://github.com/geoffryan/afterglowpy/blob/master/README.md:\n\n\njetType can be:\n1. -1 (Top Hat)\n2. 0 (Gaussian)\n3. 1 (Power Law w/ core)\n4. 2 (Gaussian w/ core)\n5. 3 (Cocoon)\n6. 4 (Smooth Power Law).\n\n\n# Exercise 2a)\n\nThe first three cells are mostly complete and will produce an optical Top Hat jet AG lightcurve plot. Using these cells as an example, produce a AG lightcurves for a Gaussian Jet and a Smooth Power Law Jet.\n\n\n```python\n# in order to do run the cells below, uncomment these two lines, run this cell, and then \n# recomment since you only have to do it once!\n\n!pip install afterglowpy \n\nimport afterglowpy as grb\n```\n\n\n```python\n# Example based on Github code by Geoff Ryan (github.com/geoffryan/afterglowpy/)\n\n# JET PARAMETERS:\n\nthetaObs = 0.05 # Viewing angle in radians\nE0 = 1.0e51 # Isotropic-equivalent energy in erg\nthetaC = 0.2 # Half-opening angle in radians, range of 0.015 - 0.021 radians\nthetaW = 0.1 # Truncation angle, unused for top-hat\nb = 0.01 # power law index, unused for top-hat\nn0 = 1.0 # circumburst density in cm^{-3}\np = 2.2 # electron energy distribution index\neps_e = 0.1 # epsilon_e\neps_B = 0.01 # epsilon_B\nxi_N = 1.0 # Fraction of electrons accelerated\nspecType = 0 # global cooling time, no inverse compton\nq = 0 # keep as 0\nts = 0 # keep as 0\nz = 0.356 # redshift, keep this\n\ndist = cosmo.luminosity_distance(z) # outputs distances in Mpc, keep this\ndL = dist.value * 3.086e24 # Luminosity distance of burst in cm, keep this\n```\n\n\n```python\n# creating a grid of times for the x-axis of our afterglow lightcurves\n\nprint(\"Choose time range\")\n\nta = 2.0 * grb.day2sec\ntb = 50 * grb.day2sec\ntsec = np.geomspace(ta, tb, num=100)\n\n# Calculate flux in a single optical band (all times have same frequency)\nnu = np.empty(tsec.shape)\nnu[:] = 4.8e14\n\n# For convenience, place positional arguments in an array and keywords into a dict\n\nY = np.array([thetaObs, E0, thetaC, thetaW, b, specType, q, ts, n0, p, eps_e, eps_B, xi_N, dL])\nZ = {'z': z}\n\n# Calculate!\n\njetType_top = -1 # top hat jet\n\nprint(\"Calculate Top Hat Jet\")\nFnu_top = grb.fluxDensity(tsec, nu, jetType_top, 0, *Y, **Z)\n\n# Change time units back to days\n\nt = tsec * grb.sec2day\n\n# Plot!\nprint(\"Plot!\")\n\nplt.plot(t,Fnu_top)\nplt.yscale('log')\nplt.xlabel('Time since Burst (Days)')\nplt.ylabel(r'$F_{nu}$ (mJy)')\nplt.title('Example 1: Top Hat Optical Afterglow Lightcurve')\nplt.show()\n```\n\n# Exercise 2b\n\nCalculate Top Hat, Gaussian and Power Law jet afterglow lightcurves.\n\n\n```python\n# Set up array of relevant times\nta = 2.0 * grb.day2sec\ntb = 50.0 * grb.day2sec\ntsec = np.geomspace(ta, tb, num=100)\n\n# Calculate flux in a single optical band (all times have same frequency)\n\nnu = np.empty(tsec.shape)\nnu[:] = 4.8e14 # approximate r-band frequency\n\n# recall number that corresponds to Gaussian jet\njetType_gau = \n\n# recall number that corresponds to Power Law jet\njetType_pl = \n\n# Calculate the brightness of your jet!\n\nprint('Calculate Top Hat Jet')\nFnu_top = grb.fluxDensity() # fill in\nprint('Calculate Gaussian Jet')\nFnu_gau = grb.fluxDensity() # fill in\nprint('Calculate Power Law Jet')\nFnu_pl = grb.fluxDensity() # fill in\n\n# change time back to days\n\nt = tsec * grb.sec2day\n\nprint(\"Plot!\")\n\nplt.plot(t,Fnu_top, ls = ':', lw=4, label = 'Top Hat') # fill in label\nplt.plot(t,Fnu_gau, label = 'Gaussian') # fill in label\nplt.plot(t,Fnu_pl, ls = '-.', label = 'Power Law') # fill in label\nplt.yscale('log')\nplt.xlabel('Days since burst') # fill in\nplt.ylabel(r'$F_{nu}$ (muJy)') # fill in\nplt.title('Afterglow Models')\nplt.legend(fontsize=14)\nplt.show()\n```\n\n# Exercise 3a\n\nReplot your four afterglows from Exercise 2 with the real optical afterglow dataset of the SGRB 130603B. Determine which afterglow jet model best fits the data. Explain why in the cell below.\n\n\n```python\n# Load in SGRB 130603B dataset\n\nobs = np.loadtxt('130603b_OmuJy.txt')\n\ntime = obs[:,0]\nfilt = obs[:,2]\nflux = obs[:,3]\nferr = obs[:,4]\ndet = obs[:,5]\n\n# Add condition to only choose points at a certain wavelengths where something was detected\n\ncond = (filt > 0.5) & (filt < 0.7) & (det == 1)\n\ntime=time[cond]\nfil = filt[cond]\nfl = flux[cond] * 1e-6 # convert micro-Jansky to Jansky to match model units\nflerr = ferr[cond] * 1e-6 # convert micro-Jansky to Jansky\n\n# Plotting the data with error bars\n\nplt.errorbar(time,fl,yerr=flerr,capsize=3,fmt='o',color='xkcd:shocking pink')\n\n# Re-plot your Top Hat, Gaussian, Power Law and Gaussian w/ core afterglow models\n\nplt.plot(t, , ls = ':',lw=4, label = 'Top Hat') # fill in\nplt.plot(t, , label = 'Gaussian') # fill in \nplt.plot(t, , ls = '-.', label = 'Power Law') # fill in\nplt.yscale('log')\n\nplt.xlabel('Days since burst')\nplt.ylabel(r'$F_{nu}$ (Jy)')\nplt.legend()\nplt.show()\n```\n\n#### Question: Which jet type(s) fit the optical afterglow of GRB 130603B the best?\n\nAnswer:\n\n## Exercise 3a Challenge: Choose the model you think fits the data best and adjust the jet parameters (what goes into Y) to determine the best fit by eye.\n\nRecommended: E0, thetaC, thetaW. Try it below and record your best fits to the data.\n\n\n```python\nthetaObs = 0.0 # Viewing angle in radians\nE0 = 1.0e53 # Isotropic-equivalent energy in erg\nthetaC = 0.1 # Half-opening angle in radians\nthetaW = 0.1 # Truncation angle, unused for top-hat\nb = .01 # power law index, unused for top-hat\nn0 = 1.0 # circumburst density in cm^{-3}\np = 2.2 # electron energy distribution index\neps_e = 0.1 # epsilon_e\neps_B = 0.01 # epsilon_B\nxi_N = 1.0 # Fraction of electrons accelerated\nspecType = 0 # global cooling time, no inverse compton\n\n# repeat process to get new lightcurves\n\n\n\n# plot\n\n\n\n```\n\n# Exercise 4\n\nNow determine the best energy fit value for SGRB 090510.\n\n\n```python\nthetaObs = 0.05 # Viewing angle in radians\nE0 = # choose # Isotropic-equivalent energy in erg\nthetaC = 0.1 # Half-opening angle in radians\nthetaW = 0.1 # Truncation angle, unused for top-hat\nb = .01 # power law index, unused for top-hat\nn0 = 1.0 # circumburst density in cm^{-3}\np = 2.2 # electron energy distribution index\neps_e = 0.1 # epsilon_e\neps_B = 0.01 # epsilon_B\nxi_N = 1.0 # Fraction of electrons accelerated\n```\n\n\n```python\n# Load in SGRB 090510 dataset (see 130603B for example)\n\nobs = np.loadtxt('090510_OmuJy.txt')\n\ntime = obs[:,0]\nfilt = obs[:,1]\nflux = obs[:,2]\nferr = obs[:,3]\ndet = obs[:,4]\n\ncond = \n\ntime =\nfil = \nfl = \nflerr = \n```\n\n\n```python\n# Choose time range\n\nta = grb.day2sec * # choose lower time\ntb = grb.day2sec * # choose upper time\ntsec = np.geomspace() # write\n\nprint('Time range chosen')\n\n# Calculate flux in a single optical band (all times have same frequency)\n\nnu = np.empty(tsec.shape)\nnu[:] = 4.8e14 # approximate r-band frequency\n\nY = np.array([thetaObs, E0, thetaC, thetaW, b, specType, q, ts, n0, p, eps_e, eps_B, xi_N, dL])\nZ = {'z': z}\n\n# Calculate!\n\nFnu_gau = \n\nprint(\"Calculated Gaussian Jet flux\")\n\n# Convert time back to days and plot!\n\nt = \n\nprint(\"Plot Observed Data\")\n\nplt.errorbar(time,fl,yerr=flerr,capsize=3,fmt='o',color='xkcd:shocking pink')\n\nprint(\"Plot Models\")\n\nplt.plot(t,Fnu_gau, label = 'Gaussian')\nplt.yscale('log')\nplt.xlabel('Time since burst (days)')\nplt.ylabel(r'$F_{nu}$ (Jy)')\nplt.title('090510 Afterglow Models')\nplt.legend(fontsize=14)\nplt.show()\n```\n\n# Exercise 4\n\n## Creating multiwavelength afterglow lightcurves\n\nSGRB 050724 was the first short gamma-ray burst whose afterglow was detected in the X-ray, optical, near-infrared and radio parts of the EM spectrum. As time went by, astronomers started sampling the afterglows more frequenctly across wavelengths. Here, we will compare the multiwavelength observations from the 130603B with our lightcurves for different jet types. Data from Table 1, Fong, Berger, Metzger et al. 2013 (https://iopscience.iop.org/article/10.1088/0004-637X/780/2/118/pdf).\n\n## Unit conversions\n\nIn order to produce lightcurves in the correct units, we must provide the models with the correct units of frequency, $\\nu$. We can calculate $\\nu$ from wavelength $\\lambda$ by:\n\n\\begin{equation}\nc = \\lambda * \\nu\n\\end{equation}\n\nWhere $c$ is the speed of light ($c=3*10^{10}$ cm/s), $\\nu$ is frequency, and $\\lambda$ is wavelength.\n\nBelow is the electromagnetic spectrum with approximate values for $\\lambda$. As $\\texttt{afterglowpy}$ only accepts $\\nu$ values, you'll need to convert to frequency to calculate your multiwavelength afterglow lightcurves. Below is an EM spectrum with frequency and wavelength so you can check you have approximately the correct values. However, I'll give you the exact wavelength values below to calculate.\n\n\n\n# Part 4a) \n\nCalculating frequency of each band\n\n\n```python\n# calculate X-ray, optical, near infrared and radio frequencies in Hz given \n\nc = 3e10 # units = cm/s\n\nlambda_xray = 1.24e-7 # cm units\nnu_xray = \n\nlambda_opt = 0.62e-4 # cm units\nnu_opt = \n\nlambda_nir = 1.2e-4 # cm units\nnu_nir = \n\nlambda_rad = 4.5e0 # cm units\nnu_rad = \n```\n\n\n```python\n# Preliminary Jet parameters - leave for now, can play with later!\n\nthetaObs = 0.05 # Viewing angle in radians\nE0 = 1.0e51 # Isotropic-equivalent energy in erg\nthetaC = 0.1 # Half-opening angle in radians\nthetaW = 0.1 # Truncation angle, unused for top-hat\nb = .01 # power law index, unused for top-hat\nn0 = 1.0 # circumburst density in cm^{-3}\np = 2.2 # electron energy distribution index\neps_e = 0.1 # epsilon_e\neps_B = 0.01 # epsilon_B\nxi_N = 1.0 # Fraction of electrons accelerated\nspecType = 0 # global cooling time, no inverse compton\n```\n\n# Part 4b) \n\nLoad in observed multiwavelength data and sort it part filter (X-ray, Optical, Near-Infrared, and Radio) by detection (q = 1) or upper limit (q = 0). Upper limits can be useful because they can help us rule out models that are too bright.\n\n\n```python\n# Load in data\n\nobs = np.loadtxt('multiwave_OmuJy.txt')\n\ndt = obs[:,0] # time in days\nfilt = obs[:,1] # filter in microns (1 micron = 10000 centimeters)\n\nprint(filt) # print to see which part of the spectrum the data was taken at\n\nflux = obs[:,2] # flux in microJansky\nferr = obs[:,3] # flux error in microJansky\n\ndet = obs[:,4] # detection = 1, upper limit = 0\n\n# Separate data by filter and if detection or upper limit\n\n\n\n```\n\n# Part 4c)\n\nCreate multiwavelength models using frequencies calculated in Part 4a) and plot with observations.\n\n\n```python\n# Choose appropriate time range\n\nta = grb.day2sec * # choose lower time\ntb = grb.day2sec * # choose upper time\ntsec = np.geomspace() # write\n\n# calculate multiwavelength lightcurves\n\nprint(\"Calc Radio\")\nFnuR = grb.fluxDensity()\nprint(\"Calc Optical\")\nFnuO = grb.fluxDensity()\nprint(\"Calc Near Infrared\")\nFnuN = grb.fluxDensity()\nprint(\"Calc X-ray\")\nFnuX = grb.fluxDensity()\n\n# plot data by filter - make sure to use different markers for detections and upper limits\n\n\n\n\n# plot models\n\nprint(\"Plot\")\n\nt = \n\nplt.plot(t,FnuR, label = 'Radio')\nplt.plot(t,FnuO, label = 'Optical')\nplt.plot(t,FnuN, label = 'Near-Infrared')\nplt.plot(t,FnuX, label = 'X-ray')\n\nplt.yscale('log')\nplt.xlabel('') # add in\nplt.ylabel(r'') # add in\nplt.title('') # add in\nplt.legend(fontsize=14)\nplt.show()\n```\n\n# Part 4d)\n\nPlay with your Jet parameters and jetType to get the best fit to all of the detections and upper limits.\n\n\n```python\n# Work space for 4d\n```\n\n#### Question: Which jet type fits the data best?\n\nAnswer:\n\n# Nice job!\n\nIf you finished early, here's a challenge:\n\nWe have been determining the best models by eye for these exercises. However, in practice astronomers like to use statistics to make sure we are finding the best fit. To do this, we must:\n\n1. Determine how to quantitatively measuring how good a fit is\n2. Minimize or maximize this quantity to make sure we have the best fit possible\n \nFeel free to ask more questions! I'm happy to help provide resources for smart ways to do this.\n\n\n```python\n\n```\n", "meta": {"hexsha": "ac847b85a64f6757af67a5c56678554a7bfe440f", "size": 30831, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Projects/SGRB-AfterglowModeling/SGRB_Afterglow_Modeling.ipynb", "max_stars_repo_name": "psheehan/CIERA-HS-Program", "max_stars_repo_head_hexsha": "76f7f0ff994e74e646fa34bbb41c314bf7526e9b", "max_stars_repo_licenses": ["Naumen", "Condor-1.1", "MS-PL"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2019-06-25T02:36:49.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-09T21:44:41.000Z", "max_issues_repo_path": "Projects/SGRB-AfterglowModeling/SGRB_Afterglow_Modeling.ipynb", "max_issues_repo_name": "psheehan/CIERA-HS-Program", "max_issues_repo_head_hexsha": "76f7f0ff994e74e646fa34bbb41c314bf7526e9b", "max_issues_repo_licenses": ["Naumen", "Condor-1.1", "MS-PL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Projects/SGRB-AfterglowModeling/SGRB_Afterglow_Modeling.ipynb", "max_forks_repo_name": "psheehan/CIERA-HS-Program", "max_forks_repo_head_hexsha": "76f7f0ff994e74e646fa34bbb41c314bf7526e9b", "max_forks_repo_licenses": ["Naumen", "Condor-1.1", "MS-PL"], "max_forks_count": 7, "max_forks_repo_forks_event_min_datetime": "2019-06-25T15:33:10.000Z", "max_forks_repo_forks_event_max_datetime": "2021-05-12T18:04:36.000Z", "avg_line_length": 32.7989361702, "max_line_length": 647, "alphanum_fraction": 0.5813953488, "converted": true, "num_tokens": 5402, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.48438008427698437, "lm_q2_score": 0.16238003666671086, "lm_q1q2_score": 0.07865365584552121}}
{"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\n\nToggle cell visibility here.\n\n\n## State feedback control - sledenje referenčni vrednosti\n\nZa sistem definiran z enačbo:\n\n$$\n\\dot{x}=\\underbrace{\\begin{bmatrix}-3&4\\\\0&2\\end{bmatrix}}_{A}x+\\underbrace{\\begin{bmatrix}0\\\\1\\end{bmatrix}}_{B}u.\n$$\n\nje dana zahteva, da prva spremenljivka stanj sledi sinusoidni referenčni funkciji s frekvenco 6 rad/s ($\\approx 1$ Hz) brez odstopanja v amplitudi. \n\nV prvem koraku dodamo integrator (z uvedbo fiktivne spremenljivke stanje; postopek je razložen v interaktivnem primeru [Krmiljenje povratne zveze stanj - zmogljivost krmiljenja](SS-31-Krmiljenje_povratne_zveze_stanj_zmogljivost)) tako, da preverimo da razširjen sistem ostane vodljiv, kar je pomembno, da se zaprtozančna prenosna funkcija od reference do $x_1$ začne pri vrednosti 0 dB. Končni razširjen sistem tako zapišemo kot:\n\n$$\n\\dot{x}_a=\\underbrace{\\begin{bmatrix}-3&4&0\\\\0&2&0\\\\1&0&0\\end{bmatrix}}_{A_a}x_a+\\underbrace{\\begin{bmatrix}0\\\\1\\\\0\\end{bmatrix}}_{B_a}u+\\underbrace{\\begin{bmatrix}0\\\\0\\\\-1\\end{bmatrix}}_{B_{\\text{ref}}}x_{1r}\\,.\n$$\n\nZ namenom zagotovitve dani zahtevi je ključno, da si predstavljamo obliko prenosne funkcije, ki zagotavlja zahtevan odziv, tj. 0 dB od $\\omega=0$ do najmanj $\\omega=6$ in fazo 0 deg v enakem intervalu frekvenc. Ob upoštevanju učinka polov v območje frekvenc izvedn danega intervala je rešitev ta, da prilagodimo pole tako, da le-ti ležijo v območju frekvenc višjih od 65 rad/s.\n\nIzbrani poli so tako $\\lambda_{1,2,3}= 65$ rad/s, matrika ojačanja pa $K_a = \\begin{bmatrix}3024.75&194&68656.25\\end{bmatrix}^T$. \n\nKrmiljeni sistem zapišemo kot:\n\n$$\n\\dot{x}_a=\\underbrace{\\begin{bmatrix}-3&4&0\\\\-3024.75&-192&-68656.25\\\\1&0&0\\end{bmatrix}}_{A_a-B_aK_a}x_a+\\underbrace{\\begin{bmatrix}0\\\\1\\\\0\\end{bmatrix}}_{B_a}v+\\underbrace{\\begin{bmatrix}0\\\\0\\\\-1\\end{bmatrix}}_{B_{\\text{ref}}}x_{1r}\n$$\n\nV tem primeru je prikazana simulacija skupaj z Bodejeveim diagramom prenosne funkcije od reference $x_{1r}$ do spremenljivke stanja $x_1$. \n\n### Kako upravljati s tem interaktivnim primerom?\nZanimivo bi bilo doseči tudi odziv brez odstopka v faznem delu signala. Kako daleč je potrebno, za dosego tega scenarija, prestaviti pole?\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('-3 4 0; 0 2 0; 1 0 0')\nB = numpy.matrix('0; 1; 0')\nBr = numpy.matrix('0; 0; -1')\nC = numpy.matrix('1 0 0')\nX0 = numpy.matrix('0; 0; 0')\nK = numpy.matrix([842.25,104,10718.75])\n\nAw = matrixWidget(3,3)\nAw.setM(A)\nBw = matrixWidget(3,1)\nBw.setM(B)\nBrw = matrixWidget(3,1)\nBrw.setM(Br)\nCw = matrixWidget(1,3)\nCw.setM(C)\nX0w = matrixWidget(3,1)\nX0w.setM(X0)\nKw = matrixWidget(1,3)\nKw.setM(K)\n\n\neig1c = matrixWidget(1,1)\neig2c = matrixWidget(2,1)\neig3c = matrixWidget(1,1)\neig1c.setM(numpy.matrix([-65])) \neig2c.setM(numpy.matrix([[-65],[0]]))\neig3c.setM(numpy.matrix([-65]))\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= ['Nastavi K', 'Nastavi lastne vrednosti'],\n value= 'Nastavi K',\n description='',\n disabled=False\n)\n\n# Define the number of complex eigenvalues for the observer\nselc = widgets.Dropdown(\n options= ['brez kompleksnih lastnih vrednosti', 'dve kompleksni lastni vrednosti'],\n value= 'brez kompleksnih lastnih vrednosti',\n description='Lastne vrednosti:',\n disabled=False\n)\n\n#define type of ipout \nselu = widgets.Dropdown(\n options=['impulzna funkcija', 'koračna funkcija', 'sinusoidna funkcija', 'kvadratni val'],\n value='impulzna funkcija',\n description='Vhod:',\n disabled=False,\n style = {'description_width': 'initial'}\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='Referenca:',\n disabled=False,\n continuous_update=False,\n orientation='horizontal',\n readout=True,\n readout_format='.1f',\n)\nperiod = widgets.FloatSlider(\n value=1,\n min=0.01,\n max=4,\n step=0.01,\n description='Perioda: ',\n disabled=False,\n continuous_update=False,\n orientation='horizontal',\n readout=True,\n readout_format='.2f',\n)\n```\n\n\n```python\n# Support functions\n\ndef eigen_choice(selc):\n if selc == 'brez kompleksnih lastnih vrednosti':\n eig1c.children[0].children[0].disabled = False\n eig2c.children[1].children[0].disabled = True\n eigc = 0\n if selc == 'dve kompleksni lastni vrednosti':\n eig1c.children[0].children[0].disabled = True\n eig2c.children[1].children[0].disabled = False\n eigc = 2\n return eigc\n\ndef method_choice(selm):\n if selm == 'Nastavi K':\n method = 1\n selc.disabled = True\n if selm == 'Nastavi lastne vrednosti':\n method = 2\n selc.disabled = False\n return method\n```\n\n\n```python\ndef main_callback(Aw, Bw, Brw, X0w, K, eig1c, eig2c, eig3c, u, period, selm, selc, selu, DW):\n A, B, Br = Aw, Bw, Brw \n sols = numpy.linalg.eig(A)\n eigc = eigen_choice(selc)\n method = method_choice(selm)\n \n if method == 1:\n sol = numpy.linalg.eig(A-B*K)\n if method == 2:\n if eigc == 0:\n K = control.acker(A, B, [eig1c[0,0], eig2c[0,0], eig3c[0,0]])\n Kw.setM(K) \n if eigc == 2:\n K = control.acker(A, B, [eig1c[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 sol = numpy.linalg.eig(A-B*K)\n print('Lastne vrednosti sistema so:',round(sols[0][0],4),',',round(sols[0][1],4),'in',round(sols[0][2],4))\n print('Lastne vrednosti krmiljenega sistema so:',round(sol[0][0],4),',',round(sol[0][1],4),'in',round(sol[0][2],4))\n \n sys = sss(A-B*K,Br,C,0)\n T = numpy.linspace(0, 6, 1000)\n \n if selu == 'impulzna funkcija': #selu\n U = [0 for t in range(0,len(T))]\n U[0] = u\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n if selu == 'koračna funkcija':\n U = [u for t in range(0,len(T))]\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n if selu == 'sinusoidna funkcija':\n U = u*numpy.sin(2*numpy.pi/period*T)\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n if selu == 'kvadratni val':\n U = u*numpy.sign(numpy.sin(2*numpy.pi/period*T))\n T, yout, xout = control.forced_response(sys,T,U,X0w)\n \n fig = plt.figure(num='Bodejev diagram', figsize=(16,10))\n control.bode_plot(sys)\n fig.suptitle('Bodejev diagram', fontsize=16)\n \n plt.figure(num='Simulacija', figsize=(16,4))\n plt.title('Odziv prve spremenljivke stanj')\n plt.ylabel('$X_1$ vs ref')\n plt.plot(T,xout[0],T,U,'r--')\n plt.xlabel('$t$ [s]')\n plt.legend(['$x_1$','Referenca'])\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 selc, \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('Lastne vrednosti:',border=3), \n eig1c, \n eig2c, \n eig3c,\n widgets.Label(' ',border=3),\n widgets.Label(' ',border=3),\n widgets.Label('X0:',border=3), X0w]),\n widgets.Label(' ',border=3),\n widgets.HBox([u, \n period, \n START]),\n widgets.Label(' ',border=3),\n widgets.HBox([widgets.Label('Dinamična matrika Aa:',border=3),\n Aw,\n widgets.Label('Vhodna matrika Ba:',border=3),\n Bw,\n widgets.Label('Referenčna matrika Br:',border=3),\n Brw])])\nout = widgets.interactive_output(main_callback, {'Aw':Aw, 'Bw':Bw, 'Brw':Brw, 'X0w':X0w, 'K':Kw, 'eig1c':eig1c, 'eig2c':eig2c, 'eig3c':eig3c, \n 'u':u, 'period':period, 'selm':selm, 'selc':selc, 'selu':selu, 'DW':DW})\nout.layout.height = '1050px'\ndisplay(out, alltogether)\n```\n\n\n Output(layout=Layout(height='1050px'))\n\n\n\n VBox(children=(HBox(children=(Dropdown(options=('Nastavi K', 'Nastavi lastne vrednosti'), value='Nastavi K'), …\n\n", "meta": {"hexsha": "602caddb36977f33cd61d9ac4786de7f014ef647", "size": 19499, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ICCT_si/examples/04/SS-32-Krmiljenje_povratne_zveze_stanj_sledenje.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/04/SS-32-Krmiljenje_povratne_zveze_stanj_sledenje.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/04/SS-32-Krmiljenje_povratne_zveze_stanj_sledenje.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.3919191919, "max_line_length": 438, "alphanum_fraction": 0.4891020052, "converted": true, "num_tokens": 4066, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014733397551624, "lm_q2_score": 0.18242552825126704, "lm_q1q2_score": 0.07846985462635774}}
{"text": "\n# PHY321: Classical Mechanics 1\n\n \n**Homework 5, due Monday February 17**\n\nDate: **Feb 8, 2021**\n\n### Practicalities about homeworks and projects\n\n1. You can work in groups (optimal groups are often 2-3 people) or by yourself. If you work as a group you can hand in one answer only if you wish. **Remember to write your name(s)**!\n\n2. Homeworks are available Wednesday/Thursday the week before the deadline. The deadline is at the Friday lecture.\n\n3. How do I(we) hand in? You can hand in the paper and pencil exercises as a hand-written document. For this homework this applies to exercises 1-5. Alternatively, you can hand in everyhting (if you are ok with typing mathematical formulae using say Latex) as a jupyter notebook at D2L. The numerical exercise(s) (exercise 6 here) should always be handed in as a jupyter notebook by the deadline at D2L. \n\n### Introduction to homework 5\n\nThis week's sets of classical pen and paper and computational\nexercises are a continuation of the topics from the previous homework set. We keep dealing with simple motion problems and conservation laws; energy, momentum and angular momentum. These conservation laws are central in Physics and understanding them properly lays the foundation for understanding and analyzing more complicated physics problems.\nThe relevant reading background is\n1. chapters 3 and 4 of Taylor (there are many good examples there) and\n\n2. chapters 10-14 of Malthe-Sørenssen.\n\nIn both textbooks there are many nice worked out examples. Malthe-Sørenssen's text contains also several coding examples you may find useful. \n\nThe numerical homework focuses on another motion problem where you can\nuse the code you developed in homework 4, almost entirely. Please take\na look at the posted solution (jupyter-notebook) for homework 4. You\nneed only to change the forces at play. The problem at hand is again a\nclassic one, a block fastened to a spring moving back and forth along the $x$-axis. It is a simpler problem compared to the previous homework. It allows us however to introduce damping (friction) and study more realistic situations. \n\n\n\n### Exercise 1 (15 pt), Work-energy theorem and conservation laws\n\nThis exercise was partly discussed during the lectures. It has not yet been edited in the online notes.\nWe will 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}_x.\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\n* 1a (2pt) Is this a conservative force? And if so, what does that imply?\n\nThis is indeed a conservative force since it depends only on position and its **curl** is zero. This means that energy is conserved and the integral over the work done by the force is independent of the path taken. \n* 1b (4pt) Use the work-energy theorem to find the velocity $v(x)$. \n\nUsing the work-energy theorem we can find the work $W$ done when moving an electron from a position $x_\\\n0$ to a final position $x$ through 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* 1c (4pt) With the above expression for the force, find the potential energy.\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 previous answer. \nWe can now, in order to find a more explicit expression for the potential energy at a given value $x$, define a zero level value for the potential. The potential is defined , using the work-energy theorem , 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 gradient of the potential, and in that case the undefined constant vanishes. The constant does not affect the force we derive from the potential.\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* 1d (5pt) Make a plot of the potential energy and discuss the equilibrium points where the force on the electron is zero. Discuss the physical interpretation of stable and unstable equilibrium points. Use energy conservation. \n\nThe following Python code plots the potential\n\n\n```python\n%matplotlib inline\n\nimport numpy as np\nimport pandas as pd\nfrom math import *\nimport matplotlib.pyplot as plt\nDeltax = 0.01\n#set up arrays\nxinitial = -2.0\nxfinal = 2.0 \nn = ceil((xfinal-xinitial)/Deltax)\nx = np.zeros(n)\nfor i in range(n):\n x[i] = xinitial+i*Deltax\nV = np.zeros(n)\n# Setting values for the constants. \nF0 = 1.0; b = 1.0; \n# Defining the potential\nV = F0*b/(2*pi)*np.cos(2*pi*x/b)\n# Plot position as function of time \nfig, ax = plt.subplots()\nax.set_ylabel('x')\nax.set_xlabel('V')\nax.plot(x, V)\nfig.tight_layout()\nplt.show()\n```\n\nWe have stable equilibrium points for every minimum of the $\\cos$ function and unstable equilibrium points where it has its maximimum values. At the minimum the particle has the lowest potential energy and the largest kinetic energy whereas at the maxima it has the largest potential energy and lowest kinetic energy. \n### Exsercise 2 (15pt), Rocket, Momentum and mass\n\nTaylor exercise 3.11. This exercise was partly discussed during the lectures, see the notes on [Energy and Momentum etc, see the part on Momentum conservation ](https://mhjensen.github.io/Physics321/doc/pub/energyconserv/html/energyconserv.html). Taylor's chapter 3.2 covers also this example.\n\n* 3.11 a and b\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\nIn the second step we ignored the term $\\Delta M\\Delta v$ since we\nassume 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}&=&\\frac{v_e}{M}\\frac{dM}{dt}.\n\\end{eqnarray}\n$$\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\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=-v_e\\ln[(M_0-\\alpha t)/M_0]-gt.\n$$\n\n* 3.11c\n\nInserting numbers $v_e=3000$ m/s, $M_0/M=2$ and $g=9.8$ m/s$^{2}$, we find $v=900$ m/s. With $g=0$ the corresponding number is $2100$ m/s, so gravity reduces the speed acquired in the first two minutes to a little less than half its weight-free value.\n\n* 3.11d\n\nIf the thrust $\\Delta Mv_e$ is less than the weight $mg$, the rocket will just sit on the ground until it has shed enough mass that the thrust can overcome the weight, definitely not a good design. \n\n\n### Exercise 3 (10pt), More Rockets\n\nTaylor exercises 3.13 (5pt) and 3.14 (5pt). This 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\nwhich gives\n\n$$\ny(t) = v_et\\ln{M_0}-v_e\\int_0^t \\ln{M(t')}dt'-\\frac{1}{2}gt^2.\n$$\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. We obtain then that the integral gives\n\n$$\n\\int_0^t \\ln{M(t')}dt' = \\frac{1}{k}\\left(M_0\\ln{M_0}-M\\ln{M}\\right)-t,\n$$\n\nwhere we used that $M_0-M=kt$. We have assumed that mass decreases by a constant $k$ times time $t$.\nInserting into $y(t)$ we obtain then\n\n$$\ny(t) = v_et-\\frac{1}{2}gt^2-\\frac{mv_e}{k}\\ln{(\\frac{M_0}{M})}.\n$$\n\nUsing the numbers from the previous exercise with $t=2$ min we obtain that $y\\approx 40$ km.\n\nFor exercise 3.14 (5pt) we have the equation of motion which reads $Ma=kv_e-bv$ or\n\n$$\n\\frac{Mdv}{kv_e-bv}=dt.\n$$\n\nWe have that $dM/dt =-k$ (assumed a constant rate for mass change). We can then replace $dt$ by $-dM/k$ and we have\n\n$$\n\\frac{kdv}{kv_e-bv}=-\\frac{dM}{M}.\n$$\n\nIntegrating gives\n\n$$\nv = \\frac{kv_e}{b}\\left[1-(\\frac{M}{M_0})^{b/k}\\right].\n$$\n\n### Exercise 4 (10pt), Center of mass\n\nTaylor exercise 3.20. Here Taylor's chapter 3.3 can be of use. This relation will turn out to be very useful when we discuss systems of many classical particles.\n\nThe definition of the center of mass for $N$ objects can be written as\n\n$$\nM\\boldsymbol{R}=\\sum_{i=1}^Nm_i\\boldsymbol{r}_i,\n$$\n\nwhere $m_i$ and $\\boldsymbol{r}_i$ are the masses and positions of object $i$, respectively.\n\nAssume now that we have a collection of $N_1$ objects with masses $m_{1i}$ and positions $\\boldsymbol{r}_{1i}$\nwith $i=1,\\dots,N_1$ and a collection of $N_2$ objects with masses $m_{2j}$ and positions $\\boldsymbol{r}_{2j}$\nwith $j=1,\\dots,N_2$.\n\nThe total mass of the two-body system is $M=M_1+M_2=\\sum_{i=1}^{N_1}m_{1i}+\\sum_{j=1}^{N_2}m_{2j}$. The center of mass position $\\boldsymbol{R}$ of the whole system satisfies then\n\n$$\nM\\boldsymbol{R}=\\sum_{i=1}^{N_1}m_{1i}\\boldsymbol{r}_{1i}+\\sum_{j=1}^{N_2}m_{2j}\\boldsymbol{r}_{2j}=M_1\\boldsymbol{R}_1+M_2\\boldsymbol{R}_2,\n$$\n\nwhere $\\boldsymbol{R}_1$ and $\\boldsymbol{R}_2$ are the the center of mass positions of the two separate bodies and the second equality follows from our rewritten definition of the center of mass applied to each body separately. This is the required result.\n\n### Exercise 5 (10pt), Sliding Block and Spring (please not again), Scaling the Equations and getting started with numerical project\n\nThe relevant material with codes etc is covered by the [Lecture Notes on Oscillations](https://mhjensen.github.io/Physics321/doc/pub/harmonic/html/harmonic.html). Taylor's chapter 5, in particular sections 5.1 amd 5.2. 5.4 is relevant for the bonus exercise.\nWe start now with our next numerical application with simple rewrites of our equations. The system we will look at is that of a block fastened to a spring (which in turn is tied to a wall).\nThe force acting on the block from the spring in the $x$-drection only is\n\n$$\nm\\frac{d^2x(t)}{dt^2}=F(x) = -k(x-b),\n$$\n\nwhere $k$ is a material specific constant and $b$ is the equilibrium position. The block has mass $m$ and $t$ is time. Define the initial time as $t_0$. We will for simplicity set the equilibrium position to zero, that is $b=0$.\n\n* 5a (3pt) Does this force conserve energy? If so, with given initial position and velocity $x_0$ and $v_0$, respectively, find the expression for energy conservation in terms of the potential and kinetic energies. \n\nThis force depdens only on the position and its **curl** is also zero. Energy is thus conserved.\nIntegrating the force gives us a potential energy $1/2kx^2$. With initial conditions for the position $x_0$ and the velocity $v_0$ we have that\n\n$$\n\\frac{1}{2}kx^2+\\frac{1}{2}mv^2=\\frac{1}{2}kx_0^2+\\frac{1}{2}mv_0^2.\n$$\n\n* 5b (3pt) Define a constant $\\omega_0=\\sqrt{k/m}$ and show that you can write the acceleration as $a(t) = -\\omega_0^2 x(t)$. What is the dimentionality of $\\omega_0$? (it is normally called a natural frequency). \n\nThe dimensionality of $\\omega_0$ is inverse time. The acceleration is\n\n$$\na=\\frac{d^2x(t)}{dt^2}=\\frac{F}{m} = -\\frac{k}{m}x=-\\omega_0^2x.\n$$\n\n* 5c (4pt) Introduce now a dimensionless time $\\tau = t\\omega_0$. Show that you can rewrite the equation for the acceleration in terms of two first-order differential equations\n\nStarting with\n\n$$\na=\\frac{d^2x}{dt^2}=\\frac{F}{m} = -\\frac{k}{m}x=-\\omega_0^2x,\n$$\n\nand introducing a dimensionless time we have\n\n$$\n\\omega_0^2\\frac{d^2x}{d\\tau^2}=-\\omega_0^2x,\n$$\n\nand dividing by $\\omega_0^2$ we have\n\n$$\n\\frac{d^2x(t)}{d\\tau^2}=\\frac{dv}{d\\tau}=-x.\n$$\n\nThis gives us our first differential equation\n\n$$\n\\frac{dv}{d\\tau} = -x,\n$$\n\nand using the definition of velocity we have\n\n$$\n\\frac{dx}{d\\tau} = v.\n$$\n\nBoth equations (velocity and position) have dimensionality length.\nNote that in principle we should have relabeled $v$ as $\\overline{v}$ to indicate that it has dimension length and not length divided by time.\n\n\n### Exercises 6 and 7\n\nThe results are detailed in the lecture notes on oscillations. The text here is simply an iteration of what we have discussed during the lectures.\n\n\nWe consider only the case where the damping force is proportional to\nthe velocity. This is counter to dragging friction, where the force is\nproportional in strength to the normal force and independent of\nvelocity, and is also inconsistent with wind resistance, where the\nmagnitude of the drag force is proportional the square of the\nvelocity. Rolling resistance does seem to be mainly proportional to\nthe velocity. However, the main motivation for considering damping\nforces proportional to the velocity is that the math is more\nfriendly. This is because the differential equation is linear,\ni.e. each term is of order $x$, $\\dot{x}$, $\\ddot{x}\\cdots$, or even\nterms with no mention of $x$, and there are no terms such as $x^2$ or\n$x\\ddot{x}$. The equations of motion for a spring with damping force\n$-b\\dot{x}$ are\n\n\n\n\n$$\n\\begin{equation}\nm\\ddot{x}+b\\dot{x}+kx=0.\n\\label{_auto1} \\tag{1}\n\\end{equation}\n$$\n\nJust to make the solution a bit less messy, we rewrite this equation as\n\n\n\n\n$$\n\\begin{equation}\n\\label{eq:dampeddiffyq} \\tag{2}\n\\ddot{x}+2\\beta\\dot{x}+\\omega_0^2x=0,~~~~\\beta\\equiv b/2m,~\\omega_0\\equiv\\sqrt{k/m}.\n\\end{equation}\n$$\n\nBoth $\\beta$ and $\\omega$ have dimensions of inverse time. To find solutions (see appendix C in the text) you must make an educated guess at the form of the solution. To do this, first realize that the solution will need an arbitrary normalization $A$ because the equation is linear. Secondly, realize that if the form is\n\n\n\n\n$$\n\\begin{equation}\nx=Ae^{rt}\n\\label{_auto2} \\tag{3}\n\\end{equation}\n$$\n\nthat each derivative simply brings out an extra power of $r$. This\nmeans that the $Ae^{rt}$ factors out and one can simply solve for an\nequation for $r$. Plugging this form into Eq. ([2](#eq:dampeddiffyq)),\n\n\n\n\n$$\n\\begin{equation}\nr^2+2\\beta r+\\omega_0^2=0.\n\\label{_auto3} \\tag{4}\n\\end{equation}\n$$\n\nBecause this is a quadratic equation there will be two solutions,\n\n\n\n\n$$\n\\begin{equation}\nr=-\\beta\\pm\\sqrt{\\beta^2-\\omega_0^2}.\n\\label{_auto4} \\tag{5}\n\\end{equation}\n$$\n\nWe refer to the two solutions as $r_1$ and $r_2$ corresponding to the\n$+$ and $-$ roots. As expected, there should be two arbitrary\nconstants involved in the solution,\n\n\n\n\n$$\n\\begin{equation}\nx=A_1e^{r_1t}+A_2e^{r_2t},\n\\label{_auto5} \\tag{6}\n\\end{equation}\n$$\n\nwhere the coefficients $A_1$ and $A_2$ are determined by initial\nconditions.\n\nThe roots listed above, $\\sqrt{\\omega_0^2-\\beta_0^2}$, will be\nimaginary if the damping is small and $\\beta<\\omega_0$. In that case,\n$r$ is complex and the factor $e{rt}$ will have some oscillatory\nbehavior. If the roots are real, there will only be exponentially\ndecaying solutions. There are three cases:\n\n\n\n### Underdamped: $\\beta<\\omega_0$\n\n$$\n\\begin{eqnarray}\nx&=&A_1e^{-\\beta t}e^{i\\omega't}+A_2e^{-\\beta t}e^{-i\\omega't},~~\\omega'\\equiv\\sqrt{\\omega_0^2-\\beta^2}\\\\\n\\nonumber\n&=&(A_1+A_2)e^{-\\beta t}\\cos\\omega't+i(A_1-A_2)e^{-\\beta t}\\sin\\omega't.\n\\end{eqnarray}\n$$\n\nHere we have made use of the identity\n$e^{i\\omega't}=\\cos\\omega't+i\\sin\\omega't$. Because the constants are\narbitrary, and because the real and imaginary parts are both solutions\nindividually, we can simply consider the real part of the solution\nalone:\n\n\n\n\n$$\n\\begin{eqnarray}\n\\label{eq:homogsolution} \\tag{7}\nx&=&B_1e^{-\\beta t}\\cos\\omega't+B_2e^{-\\beta t}\\sin\\omega't,\\\\\n\\nonumber \n\\omega'&\\equiv&\\sqrt{\\omega_0^2-\\beta^2}.\n\\end{eqnarray}\n$$\n\n### Critical dampling: $\\beta=\\omega_0$\n\nIn this case the two terms involving $r_1$ and $r_2$ are identical\nbecause $\\omega'=0$. Because we need to arbitrary constants, there\nneeds to be another solution. This is found by simply guessing, or by\ntaking the limit of $\\omega'\\rightarrow 0$ from the underdamped\nsolution. The solution is then\n\n\n\n\n$$\n\\begin{equation}\n\\label{eq:criticallydamped} \\tag{8}\nx=Ae^{-\\beta t}+Bte^{-\\beta t}.\n\\end{equation}\n$$\n\nThe critically damped solution is interesting because the solution\napproaches zero quickly, but does not oscillate. For a problem with\nzero initial velocity, the solution never crosses zero. This is a good\nchoice for designing shock absorbers or swinging doors.\n\n### Overdamped: $\\beta>\\omega_0$\n\n$$\n\\begin{eqnarray}\nx&=&A_1\\exp{-(\\beta+\\sqrt{\\beta^2-\\omega_0^2})t}+A_2\\exp{-(\\beta-\\sqrt{\\beta^2-\\omega_0^2})t}\n\\end{eqnarray}\n$$\n\nThis solution will also never pass the origin more than once, and then\nonly if the initial velocity is strong and initially toward zero.\n\n\n\n\nGiven $b$, $m$ and $\\omega_0$, find $x(t)$ for a particle whose\ninitial position is $x=0$ and has initial velocity $v_0$ (assuming an\nunderdamped solution).\n\nThe solution is of the form,\n\n$$\n\\begin{eqnarray*}\nx&=&e^{-\\beta t}\\left[A_1\\cos(\\omega' t)+A_2\\sin\\omega't\\right],\\\\\n\\dot{x}&=&-\\beta x+\\omega'e^{-\\beta t}\\left[-A_1\\sin\\omega't+A_2\\cos\\omega't\\right].\\\\\n\\omega'&\\equiv&\\sqrt{\\omega_0^2-\\beta^2},~~~\\beta\\equiv b/2m.\n\\end{eqnarray*}\n$$\n\nFrom the initial conditions, $A_1=0$ because $x(0)=0$ and $\\omega'A_2=v_0$. So\n\n$$\nx=\\frac{v_0}{\\omega'}e^{-\\beta t}\\sin\\omega't.\n$$\n\nLet us remind ourselves about the differential equation we want to solve (the general case with damping due to friction)\n\n$$\nm\\frac{d^2x}{dt^2} + b\\frac{dx}{dt}+kx(t) =0.\n$$\n\nWe divide by $m$ and introduce $\\omega_0^2=\\sqrt{k/m}$ and obtain\n\n$$\n\\frac{d^2x}{dt^2} + \\frac{b}{m}\\frac{dx}{dt}+\\omega_0^2x(t) =0.\n$$\n\nThereafter we introduce a dimensionless time $\\tau = t\\omega_0$ (check\nthat the dimensionality is correct) and rewrite our equation as\n\n$$\n\\frac{d^2x}{d\\tau^2} + \\frac{b}{m\\omega_0}\\frac{dx}{d\\tau}+x(\\tau) =0,\n$$\n\nwhich gives us\n\n$$\n\\frac{d^2x}{d\\tau^2} + \\frac{b}{m\\omega_0}\\frac{dx}{d\\tau}+x(\\tau) =0.\n$$\n\nWe then define $\\gamma = b/(2m\\omega_0)$ and rewrite our equations as\n\n$$\n\\frac{d^2x}{d\\tau^2} + 2\\gamma\\frac{dx}{d\\tau}+x(\\tau) =0.\n$$\n\nThis is the equation we will code below. The first version employs the Euler-Cromer method.\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\nfrom pylab import plt, mpl\nplt.style.use('seaborn')\nmpl.rcParams['font.family'] = 'serif'\n\nDeltaT = 0.001\n#set up arrays \ntfinal = 20 # in years\nn = ceil(tfinal/DeltaT)\n# set up arrays for t, v, and x\nt = np.zeros(n)\nv = np.zeros(n)\nx = np.zeros(n)\n# Initial conditions as simple one-dimensional arrays of time\nx0 = 1.0 \nv0 = 0.0\nx[0] = x0\nv[0] = v0\ngamma = 0.0\n# Start integrating using Euler-Cromer'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 a = -2*gamma*v[i]-x[i]\n # update velocity, time and position\n v[i+1] = v[i] + DeltaT*a\n x[i+1] = x[i] + DeltaT*v[i+1]\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('t[s]')\nax.plot(t, x)\nfig.tight_layout()\nsave_fig(\"BlockEulerCromer\")\nplt.show()\n```\n\nWhen setting up the value of $\\gamma$ we see that for $\\gamma=0$ we get the simple oscillatory motion with no damping.\nChoosing $\\gamma < 1$ leads to the classical underdamped case with oscillatory motion, but where the motion comes to an end.\n\nChoosing $\\gamma =1$ leads to what normally is called critical damping and $\\gamma> 1$ leads to critical overdamping.\nTry it out and try also to change the initial position and velocity. Setting $\\gamma=1$\nyields a situation, as discussed above, where the solution approaches quickly zero and does not oscillate. With zero initial velocity it will never cross zero.\n", "meta": {"hexsha": "75c1c360671e4515460161c963506acc05544c5c", "size": 34892, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "doc/src/Homeworks/Misc/.ipynb_checkpoints/solutionhw5-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/src/Homeworks/Misc/.ipynb_checkpoints/solutionhw5-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/src/Homeworks/Misc/.ipynb_checkpoints/solutionhw5-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.4945054945, "max_line_length": 415, "alphanum_fraction": 0.5564312736, "converted": true, "num_tokens": 6752, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO\n\n", "lm_q1_score": 0.18713268669577832, "lm_q2_score": 0.41869690935568665, "lm_q1q2_score": 0.0783518775589484}}
{"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\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## Errore a regime - Sistemi in feedback unitario\n\nData la funzione di trasferimento dell'input $I(s)$ e la funzione di trasferimento del sistema ad anello aperto $G(s)$, l'errore a regime $e(\\infty)$ del sistema ad anello chiuso può, in caso di feedback unitario, essere determinato da:\n\n\\begin{equation}\n e(\\infty)=\\lim_{s\\to0}\\frac{sI(s)}{1+G(s)}.\n\\end{equation}\n\nNel caso di una funzione di ingresso a gradino $I(s)=\\frac{1}{s}$ si ottiene:\n\n\\begin{equation}\n e_{step}(\\infty)=\\frac{1}{1+\\lim_{s\\to0}G(s)},\n\\end{equation}\n\nnel caso di una funzione di ingresso a rampa $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\ne nel caso di una funzione di ingresso parabolica $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### Sistemi senza integratori\n\nUn esempio di una funzione di trasferimento $G(s)$ di un sistema senza integratori può essere:\n\n\\begin{equation}\n G(s) = \\frac{K}{as^2 + bs + c}\n\\end{equation}\n\nL'errore a regime nel caso di sistemi senza integratori è infinito per gli ingressi a rampa e parabolici.\n\n### Sistemi con un integratore\n\nUn esempio di una funzione di trasferimento $G(s)$ di un sistema con un integratore può essere:\n\n\\begin{equation}\n G(s) = \\frac{K(as^2 + bs + c)}{s(ds^2 + es + fc)}\n\\end{equation}\n\nL'errore a regime nel caso di sistemi con un integratore è infinito per gli ingressi parabolici.\n\n---\n\n### Come usare questo notebook?\n\n- Scegli tra il sistema senza integratori a un sistema con un unico integratore.\n- Sposta i cursori per modificare i valori di $a$, $b$, $c$ (coefficienti della funzione di trasferimento) e $K$ (amplificazione).\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=[('nessun integratore', 0), ('un integratore', 1)],\n description='Sistema: ',style=style)\nfunctionSelect = widgets.ToggleButtons(\n options=[('gradino', 0), ('rampa', 1), ('parabola', 2)],\n description='Input: ',style=style)\n\nfig=plt.figure(num='Errore a regime')\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('Input, output')\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('L\\'errore a regime è infinito.')\n elif e_inf==0:\n print('L\\'errore a regime è zero.')\n else:\n print('L\\'errore a regime è uguale a %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='input',color='C0')\n responsef, = f1.plot(tout,yout,label='output',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 @slendrmeans | February 2013\n\n## Introduction (Attention Conservation Notice)\n\nThis notebook contains information that is new and useful. But the parts that are new are not useful, and the parts that are useful are not new. It exists because I wanted to experiment in Cython and in the IPython notebook. The code here is all but useless except for pedagogy. Virtually no one has any rightful business coding up their own linear algebra routines. And the mathematical and algorithmic content is elementary.\n\nWhich is all useful for my purpose: when you try out new tools you want to do it on well-known problems. And the excessive verbiage and formulas give me an excuse to tinker with the notebooks typographical capabilities.\n\nAs such this may be of no use to anyone besides the author. Consider yourself warned.\n\nComments regarding my amateur Cython, or any other topic, are welcome.\n\n## A linear system\n\nOur goal is to understand and, if possible, solve the system of $n$ linear equations\n\n$$\n\\begin{align}\na_{00}\\,x_0 + a_{01}\\,x_1 + \\ldots + a_{0,n-1}\\,x_{n-1} &= b_0 \\\\\\\na_{10}\\,x_0 + a_{11}\\,x_1 + \\ldots + a_{1,n-1}\\,x_{n-1} &= b_1 \\\\\\\n\\vdots & \\\\\\\na_{n-1,0}\\,x_0 + a_{n-1,1}\\,x_1 + \\ldots + a_{n-1,n-1}\\,x_{n-1} &= b_{n-1}\\ .\n\\end{align}\n$$\n\nIn the system, the $a_{ij}$s and $b_i$s are known, while the $x_i$s are the unkown variables we wish to solve for. In other words, solving the system means finding the values for the $x_i$s using the $a_{ij}$s and $b_i$s. \n\nUsing matrix notation, we can write the system as\n\n$$\n\\begin{pmatrix}\na_{00} & a_{01} & \\ldots & a_{0,n-1} \\\\\\\na_{10} & a_{11} & \\ldots & a_{1,n-1} \\\\\\\n\\vdots & & \\ddots & \\vdots \\\\\\\na_{n-1,0} & a_{n-1,1} & \\ldots & a_{n-1,n-1}\n\\end{pmatrix} \\,\n\\begin{pmatrix} x_0 \\\\\\ x_1 \\\\\\ \\vdots \\\\\\ x_{n-1}\\end{pmatrix}\n=\n\\begin{pmatrix} b_0 \\\\\\ b_1 \\\\\\ \\vdots \\\\\\ b_{n-1}\\end{pmatrix}\\ \n$$\n\n
\n\n\n\n# Fit of Zero-Loss Peak\n\n[Download](https://raw.githubusercontent.com/gduscher/MSE672-Introduction-to-TEM/main/Spectroscopy/CH4_02-Fit_Zero_Loss.ipynb)\n \n[](\n https://colab.research.google.com/github/gduscher/MSE672-Introduction-to-TEM/blob/main/Spectroscopy/CH4_02-Fit_Zero_Loss.ipynb)\n\n\npart of \n\n **[MSE672: Introduction to Transmission Electron Microscopy](../_MSE672_Intro_TEM.ipynb)**\n\nby Gerd Duscher, Spring 2021\n\nMicroscopy Facilities
\nJoint Institute of Advanced Materials
\nMaterials Science & Engineering
\nThe University of Tennessee, Knoxville\n\nBackground and methods to analysis and quantification of data acquired with transmission electron microscopes.\n\n\n\n## Content\n\nThe zero-loss peak in an EELS spectrum gives us two important infomations:\n * the origin of the energy-scale\n * the zero-loss peak is the resolution function of our spectrum\n \nOften we need to subtract or know this resolution function very accurately for a precise analysis of EELS spectra.\n\nThe area under the peak gives us the number of electron that are not inelatically scattered, and in relation to the total count a measure for the thickness of the sample.\n\n### Energy Resolution and Zero-Loss Peak\n\nThe first peak in the Electron Energy Loss Spectrum (EELS) is the so called ``Zero-Loss`` peak.\nThis zero-loss peak is formed by all the electrons that are\n- not scattered, \n- elastically scattered, and\n- quasi--elastically scattered.\n\n>\n>We can use it as a measure of the energy resolution of the system.}\n >\n \n This is called a response function in information theory.\n\n\nThe full width at half maximum (FWHM) of the ``Zero-Loss peak`` is what we usually declare as energy resolution in an EELS spectrum.\n\nThe energy resolution has three sources:\n- the energy spread of the electrons before they reach the specimen ($\\Delta\\mbox{E}_0$),\n- the energy spread that is added by quasi-elastic interactions with the specimen($\\Delta\\mbox{E}_{ph}$),\n- the spectrometer resolution ($\\Delta\\mbox{E}_{S_0}$),\n- the energy dispersion ($s/D$).\n\nThese components usually treated as independent and summed up as squares of their values.\nThe measured resolution $\\Delta$E is given by:\n\n\\begin{equation} \\Large \n\\label{energy-resolution} \n\\Delta{\\rm E}^2 \\approx \\Delta\\mbox{E}_0^2 + \\Delta\\mbox{E}_{S_0}^2 + (s/D)^2\n\\end{equation}\n \nPlease note that the quasi-elastic interactions are not added here and, therefore, I assume to go through the vacuum only.\n\n#### Contribution of Electron Source\n - The energy spread before the sample $\\Delta$E$_0$ is the energy spread of the electron source broadened by the Boersch effect. \n- The energy spread of the source is a directly proportional to the temperature due to the Fermi--Dirac distribution. \n- The Boersch effect is an additional broadening caused by the Coulomb interaction of the electrons, and is therefore more pronounced in higher density electron beams.\n- Monochromators will select a part of the original energy spread and thus increase energy resolution.\n#### Contribution of Spectrometer\n- The spectrometer resolution $\\Delta$E$_{S0}$ is due to the aberration of the electron optics.\n- This aberration is worse for larger collection angles.\n- Aberration correctors will improve the spectrometer resolution.\n\n#### Contribution of Detector}\n\nThe spatial resolution of the electron detector $s$ (equivalent to the width of the slid of a serial spectrometer) and the spectrometer dispersion $D$ are the final contributions to the total energy resolution.\n### Choices of Dispersion\n- A small energy dispersion will allow a high energy resolution\\\\\n- A large energy dispersion enables to samples a large energy window \n\n\n## Load important packages\n\n### Check Installed Packages\n\n\n\n```python\nimport sys\nfrom pkg_resources import get_distribution, DistributionNotFound\n\ndef test_package(package_name):\n \"\"\"Test if package exists and returns version or -1\"\"\"\n try:\n version = get_distribution(package_name).version\n except (DistributionNotFound, ImportError) as err:\n version = '-1'\n return version\n\n# Colab setup ------------------\nif 'google.colab' in sys.modules:\n !pip install pyTEMlib -q\n# pyTEMlib setup ------------------\nelse:\n if test_package('pyTEMlib') < '0.2021.3.22':\n print('installing pyTEMlib')\n !{sys.executable} -m pip install --upgrade pyTEMlib -q\n# ------------------------------\nprint('done')\n```\n\n done\n\n\n### Import all relevant libraries\n\nPlease note that the EELS_tools package from pyTEMlib is essential.\n\n\n```python\nimport sys\nif 'google.colab' in sys.modules:\n %pylab --no-import-all inline\nelse: \n %pylab --no-import-all notebook\n %gui qt\n \nimport warnings\nwarnings.filterwarnings('ignore')\n\nfrom scipy.optimize import leastsq ## fitting routine of scipy\n\n# Import libraries from the book\nimport pyTEMlib\nimport pyTEMlib.file_tools as ft # File input/ output library\nfrom pyTEMlib import eels_tools \n\n# For archiving reasons it is a good idea to print the version numbers out at this point\nprint('pyTEM version: ',pyTEMlib.__version__)\n```\n\n Populating the interactive namespace from numpy and matplotlib\n pyTEM version: 0.2021.04.02\n\n\n## Load and plot a spectrum\nplease see [Introduction to EELS](CH4_01-Introduction.ipynb) for details\n\n\n```python\n# Load file\nfilename = '../example_data/AL-DFoffset0.00.dm3'\neels_dataset = ft.open_file(filename)\nif eels_dataset.data_type.name != 'SPECTRUM':\n print('We need an EELS spectrum for this notebook')\neels_dataset.plot()\n```\n\n Cannot overwrite file. Using: AL_DFoffset0.00-1.hf5\n\n\n\n
Ukupno nam treba **{t1_s7_total_size_bytes} B**, \"\n f\"tj. **{t1_s7_total_size_bytes / 1e6:.02f} MB** memorije.\")\n```\n\n\n\n\n
Ukupno nam treba **164341200 B**, tj. **164.34 MB** memorije.\n\n\n\n**Komentar**: Naravno, s ovo je samo procjena donje granice. Tijekom izvršavanja je potrebna dodatna memorija jer nije kao da se samo pamte gradijenti koji se mijenjaju. Međutim, kako je alokacija i dealokacija ove memorije ovisna o implementaciji knjižnice i programskog jezika, pružamo procjenu samo za naučive gradijente, jer ćemo njih uvijek morati pamtiti. Isto tako, pretpostavilo se da nema kompresije podataka. Uz kompresiju (npr. rijetke matrice) bi ovi brojevi mogli biti manji.\n\n### Podzadatak 8\n\nNapokon, pokrenite učenje modela pozivom skripte `train.py`.\n\n\n```python\nt1_s8_display = \"\"\n\nif t1_do_train:\n !python3 train.py\nelse:\n t1_s8_display = \"
Postavljeno je da se treniranje **ne pokreće** \" +\\\n \"(`t1_do_train == False`).\"\n \nMarkdown(t1_s8_display)\n```\n\n\n\n\n
Postavljeno je da se treniranje **ne pokreće** (`t1_do_train == False`).\n\n\n\n### Podzadatak 9\n\nOdredite vezu između početnog iznosa funkcije gubitka i broja razreda $C$.\n\n**Odgovor**:\n\nŠto je veći broj $C$, to nasumično inicijalizirana mreža, za koju pretpostavljamo da predviđa rezultate kao da izvlači klasifikacije iz uniformne razdiobe, ima više šanse pogriješiti. Stoga, porastom broja $C$ će početni iznos funkcije gubitka rasti.\n\n# Zadatak 2 (25%)\n\n### L2 regularizacija\n\n#### [<- Zadatak 1](#Zadatak-1-%C2%A0%C2%A0%C2%A0-(25%)) [Zadatak 3 ->](#Zadatak-3-%C2%A0%C2%A0%C2%A0-(25%))\n\n## Postavke zadatka\n\n\n```python\nt2_do_train = False # True ako želite pokrenuti trening u podzadatku 1, False inače.\n # Upozorenje - to traje skoro 1 sat!\n\nt2_root_path = \"out_l2reg\"\nt2_results_path = os.path.join(t2_root_path, \"results.json\")\nt2_weight_decays = [1e-3, 1e-2, 1e-1]\n```\n\nU ovom zadatku trebate dodati podršku za L2 regularizaciju parametara.\n\n### Podzadatak 1\n\nDovršite implementaciju sloja `L2Regularizer` te naučite regularizirani model iz prethodnog zadatka koji se nalazi u `train_l2reg.py`.\n\n**Odgovor**:\n\nImplementacija `L2Regularizer` nalazi se u `layers.py`.\n\n\n```python\nt2_s1_display = \"\"\n\nif t2_do_train:\n !python3 train_l2reg.py\nelse:\n t2_s1_display = \"
Postavljeno je da se treniranje **ne pokreće** \" +\\\n \"(`t2_do_train == False`).\"\n \nMarkdown(t2_s1_display)\n```\n\n\n\n\n
Postavljeno je da se treniranje **ne pokreće** (`t2_do_train == False`).\n\n\n\n### Podzadatak 2\n\nProučite efekte regularizacijskog hiper-parametra tako da naučite tri različita modela s $\\lambda = 10^{-3}$, $\\lambda = 10^{-2}$, $\\lambda = 10^{-1}$ te usporedite naučene filtre u prvom sloju i dobivenu točnost.\n\n**Odgovor**:\n\nSpremili smo sliku u datoteke naziva `out_l2reg/lambda0.001`, `out_l2reg/lambda0.010` i `out_l2reg/lambda0.100`. Ako učitamo posljednje datoteke, možemo prikazati sljedeće slike:\n\n\n```python\nt2_s2_folder_paths = [os.path.join(t2_root_path, x) for x in sorted(os.listdir(t2_root_path))]\nt2_s2_image_paths = list()\n```\n\n\n```python\nt2_s2_figure, t2_s2_axes = plt.subplots(3, 1, figsize=(12, 9))\n\nfor i, folder_path in enumerate(t2_s2_folder_paths[:3]):\n current_image_path = os.path.join(folder_path, sorted(os.listdir(folder_path))[-1])\n\n t2_s2_axes[i].imshow(plt.imread(current_image_path), interpolation=\"nearest\")\n t2_s2_axes[i].set_title(f\"λ = {t2_weight_decays[i]}\")\n t2_s2_axes[i].axis(\"off\")\n```\n\nKonsekventno, čitanjem datoteke `out_l2reg/results.json` možemo usporediti dobivene točnosti:\n\n\n```python\nwith open(t2_results_path) as file:\n t2_s2_results = json.load(file)\n```\n\n\n```python\nt2_s2_string = \"
\"\n\nfor i, weight_decay in enumerate(sorted(t2_weight_decays)):\n t2_s2_string += f\"\\n
Točnost za λ = {weight_decay}: \" +\\\n f\"\".join([\" \" for _ in range(i)]) +\\\n f\"{t2_s2_results[str(weight_decay)]:.02f}%\"\n \nHTML(t2_s2_string)\n```\n\n\n\n\n
\n
Točnost za λ = 0.001: 99.16%\n
Točnost za λ = 0.01: 98.74%\n
Točnost za λ = 0.1: 96.53%\n\n\n\n**Komentar**:\n\nNa prvi pogled se čini kako je najmanji iznos regularizacije dao najbolju mrežu radi najveće točnosti. Ovo možda i jest istina. Međutim, ako pogledamo slike, možemo uočiti da su za $\\lambda = 10^{-2}$ prvi konvolucijski slojevi daleko interpretabilniji od ostalih - vidimo linije, krivulje, horizontalne i dijagonalne praznine i sl. Dok u dubokom učenje interpretabilnost ne rezultira bolji rezultatima, tj. obično bude i suprotno, radi se u prvom sloju, koji izvlači značajke iz slike. Prema tome, vjerojatno ćemo, ako se radi o slikama koje su jednostavne kao MNIST, imati bolje rezultate ako su i filteri prvog sloja interpretabilni.\n\n# Zadatak 3 (25%)\n\n### Usporedba s PyTorchem\n\n#### [<- Zadatak 2](#Zadatak-2-%C2%A0%C2%A0%C2%A0-(25%)) [Zadatak 4 ->](#Zadatak-4-%C2%A0%C2%A0%C2%A0-(25%))\n\n## Postavke zadatka\n\n\n```python\nt3_do_train = False # True ako želite pokrenuti trening u podzadatku 1, False inače.\n # Upozorenje - to traje skoro 1 sat!\n\nt3_root_path = \"out_task3\"\nt3_results_filename = \"results.json\"\nt3_weight_decays = [1e-3, 1e-2, 1e-1]\n```\n\nU PyTorchu definirajte i naučite model koji je ekvivalentan regulariziranom modelu iz [2. zadatka](#Zadatak-2). Koristite identičnu arhitekturu i parametre učenja da biste reproducirali rezultate. Konvoluciju zadajte operacijama [`torch.nn.Conv2d`](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d) ili [`torch.nn.functional.conv2d`](https://pytorch.org/docs/stable/nn.functional.html#torch.nn.functional.conv2d).\n\n### Podzadatak 1\n\nTijekom učenja vizualizirajte filtre u prvom sloju kao u prethodnoj vježbi. Nakon svake epohe učenja pohranite filtre i gubitak u datoteku (ili koristite [Tensorboard](https://pytorch.org/docs/stable/tensorboard.html)).\n\n\n```python\nt3_s1_display = \"\"\n\nif t3_do_train:\n t3_s1_mnist_dict = prepare_MNIST()\n\n for weight_decay in [1e-3, 1e-2, 1e-1]:\n model = CNNT3()\n model.float()\n\n model.tr(t3_s1_mnist_dict[\"x\"][0], t3_s1_mnist_dict[\"y\"][0],\n t3_s1_mnist_dict[\"x\"][1], t3_s1_mnist_dict[\"y\"][1],\n weight_decay=weight_decay)\nelse:\n t3_s1_display = \"
Postavljeno je da se treniranje ne pokreće \" +\\\n \"(t3_do_train == False).\"\n\nHTML(t3_s1_display)\n```\n\n\n\n\n
Postavljeno je da se treniranje ne pokreće (t3_do_train == False).\n\n\n\n**Komentar**\n\nUmjesto svakih $5000$ epoha, ovo ćemo raditi jednom po epohi. Ne vidim razlog zašto bi se to radilo češće jer je trening ovakve mreže volatilan samo na početku, pa bi češće spremanje slika bilo opravdano jedino u prvoj epohi.\n\n### Podzadatak 2\n\nNa kraju učenja prikažite kretanje gubitka kroz epohe (Matplotlib).\n\n**Odgovor**:\n\nPrvo ćemo učitati sve puteve do datoteka:\n\n\n```python\nt3_s2_folder_paths = [os.path.join(t3_root_path, f\"lambda{x:.03f}\") for x in t3_weight_decays]\n\nt3_s2_image_paths = list()\nt3_s2_results_paths = list()\n\nfor folder_path in t3_s2_folder_paths:\n last_filter_path = sorted([x for x in os.listdir(folder_path) if x.endswith(\".png\")],\n key=lambda x: x.lower())[-1]\n \n t3_s2_image_paths.append(os.path.join(folder_path, last_filter_path))\n t3_s2_results_paths.append(os.path.join(folder_path, t3_results_filename))\n```\n\nZatim možemo prikazati posljednje filtre za različite parametre $\\lambda$:\n\n\n```python\nt3_s2_figure, t3_s2_axes = plt.subplots(3, 1, figsize=(12, 9))\n\nfor i, image_path in enumerate(t3_s2_image_paths):\n t3_s2_axes[i].imshow(plt.imread(image_path), interpolation=\"nearest\")\n t3_s2_axes[i].set_title(f\"λ = {t2_weight_decays[i]}\")\n t3_s2_axes[i].axis(\"off\")\n```\n\nKonačno, možemo prikazati ovisnost gubitaka o epohama za sve 3 instance učenja:\n\n\n```python\nt3_s2_figure_l, t3_s2_axes_l = plt.subplots(1, 3, figsize=(16,5), sharey=True)\n\nfor i, result_path in enumerate(t3_s2_results_paths):\n with open(result_path) as file:\n loss_dict = json.load(file)\n \n loss, val_loss = [loss_dict[x] for x in [\"loss\", \"val_loss\"]]\n \n t3_s2_axes_l[i].set_title(f\"Gubitak za λ = {t3_weight_decays[i]}\")\n t3_s2_axes_l[i].set_xlabel(f\"Epohe\")\n t3_s2_axes_l[i].set_ylabel(f\"Gubitak\")\n \n t3_s2_axes_l[i].plot(range(len(loss)), loss, label=\"Gubitak učenja\", marker=\"o\")\n t3_s2_axes_l[i].plot(range(len(val_loss)), val_loss, label=\"Gubitak validacije\", marker=\"o\")\n \n t3_s2_axes_l[i].legend()\n```\n\n# Zadatak 4 (25%)\n\n### Klasifikacija na skupu CIFAR-10\n\n#### [<- Zadatak 3](#Zadatak-3-%C2%A0%C2%A0%C2%A0-(25%))\n\n## Postavke zadatka\n\n\n```python\nt4_do_train = False # True ako želite pokrenuti trening u podzadatku 2, False inače.\n # Upozorenje - to traje 30 minuta, ali sama validacija zauzima\n # oko 33 GB RAMa - pripremite veliki SWAP!\n\nt4_root_path = \"out_task4\"\n\nt4_results_tr_file_path = os.path.join(t4_root_path, \"results_tr.json\")\nt4_results_val_file_path = os.path.join(t4_root_path, \"results_val.json\")\nt4_learning_rates_file_path = os.path.join(t4_root_path, \"learning_rates.json\")\n\nt4_model_path = os.path.join(t4_root_path, \"model.pt\")\n\nt4_s5_path = os.path.join(t4_root_path, \"t4_s5\")\nt4_s5_best_classes_path = os.path.join(t4_s5_path, \"best_classes.json\")\nt4_s5_worst_classes_path = os.path.join(t4_s5_path, \"worst_classes.json\")\n```\n\nSkup podataka [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) sastoji se od $50000$ slika za učenje i validaciju te $10000$ slika za testiranje dimenzija $32 \\times 32$ podijeljenih u $10$ razreda.\n\n### Podzadatak 1\n\nNajprije skinite dataset pripremljen za Python [odavde](https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz) ili korištenjem [`torchvision.datasets.CIFAR10`](https://pytorch.org/docs/stable/torchvision/datasets.html#cifar).\n\n**Odgovor**:\n\nSkup podataka je inicijalno preuzet s [sljedeće poveznice](https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz), raspakiran i smješten u `datasets/CIFAR`.\n\n### Podzadatak 2\n\nVaš zadatak je da u PyTorchu naučite konvolucijski model na ovom skupu.\n\n**Odgovor**:\n\nOvo ćemo učiniti s nešto drukčijom arhitekturom od predložene:\n\n$\n\\begin{align}\n & \\mathrm{Conv2D \\space 64 @ 7 \\times 7} \\\\\n & \\mathrm{MaxPool(2,2)} \\\\\n & \\mathrm{PReLU} \\\\\n & \\mathrm{BatchNorm2D} \\\\\\\\\n%\n & \\mathrm{Conv2D \\space 64 @ 5 \\times 5} \\\\\n & \\mathrm{MaxPool(2,2)} \\\\\n & \\mathrm{PReLU} \\\\\n & \\mathrm{BatchNorm2D} \\\\\\\\\n%\n & \\mathrm{Conv2D \\space 64 @ 3 \\times 3} \\\\\n & \\mathrm{PReLU} \\\\\n & \\mathrm{BatchNorm2D} \\\\\n & \\mathrm{Conv2D \\space 128 @ 3 \\times 3} \\\\\n & \\mathrm{MaxPool(2,2)} \\\\\n & \\mathrm{PReLU} \\\\\n & \\mathrm{BatchNorm2D} \\\\\\\\\n%\n & \\mathrm{Flatten} \\\\\\\\\n%\n & \\mathrm{Dense(512)} \\\\\n & \\mathrm{PReLU} \\\\\n & \\mathrm{BatchNorm} \\\\\\\\\n%\n & \\mathrm{Dense(256)} \\\\\n & \\mathrm{PReLU} \\\\\n & \\mathrm{BatchNorm} \\\\\\\\\n%\n & \\mathrm{Dense(10)} \\\\\n\\end{align}\n$\n\n**Komentar**:\n\nRazlog za ovoliko drukčiji model su bolje performanse, i u smislu brže konvergencije, i u smislu postizanja bolje točnost bez augmentacije.\n\n\n```python\nt4_s2_cifar_dict = prepare_CIFAR()\n```\n\n\n```python\nt4_s2_display = \"\"\n\nif t4_do_train:\n model = CNNT4()\n model.float()\n\n model.tr(t4_s2_cifar_dict[\"x\"][0], t4_s2_cifar_dict[\"y\"][0],\n t4_s2_cifar_dict[\"x\"][1], t4_s2_cifar_dict[\"y\"][1],\n n_epochs=16, batch_size=16, weight_decay=1e-4)\n\n torch.save(model, os.path.join(t4_root_path, \"model.pt\"))\nelse:\n t4_s2_display = \"
Postavljeno je da se treniranje **ne pokreće**\" +\\\n \"(`t4_do_train == False`).\"\n\nMarkdown(t4_s2_display)\n```\n\n\n\n\n
Postavljeno je da se treniranje **ne pokreće**(`t4_do_train == False`).\n\n\n\n### Podzadatak 3\n\nNapišite funkciju `evaluate` koja na temelju predviđenih i točnih indeksa razreda određuje pokazatelje klasifikacijske performanse: ukupnu točnost klasifikacije, matricu zabune (engl. confusion matrix) u kojoj retci odgovaraju točnim razredima a stupci predikcijama te mjere preciznosti i odziva pojedinih razreda. U implementaciji prvo izračunajte matricu zabune, a onda sve ostale pokazatelje na temelju nje. Tijekom učenja pozivajte funkciju `evaluate` nakon svake epohe na skupu za učenje i validacijskom skupu te na grafu pratite sljedeće vrijednosti: prosječnu vrijednost funkcije gubitka, stopu učenja te ukupnu točnost klasifikacije. Preporuka je da funkciji provedete samo unaprijedni prolaz kroz dane primjere koristeći `torch.no_grad()` i pritom izračunati matricu zabune. Pazite da slučajno ne pozovete i operaciju koja provodi učenje tijekom evaluacije. Na kraju funkcije možete izračunati ostale pokazatelje te ih isprintati.\n\n**Odgovor**:\n\nImplementacija je ostvarena unutar klase `CNNT4` koja je unutar modula `task_4.py`:\n\n\n```python\nwith open(t4_results_tr_file_path) as file:\n t4_s3_results_tr = json.load(file)\n \nwith open(t4_results_val_file_path) as file:\n t4_s3_results_val = json.load(file)\n \nwith open(t4_learning_rates_file_path) as file:\n t4_s3_learning_rates = json.load(file)\n```\n\n\n```python\nt4_s3_metric_fig, t4_s3_metric_ax = plt.subplots(1, 2, figsize=(16,6), sharey=True)\nt4_s3_tr_metric_fig, t4_s3_tr_metric_ax = plt.subplots(1, 2, figsize=(16,6))\n\nt4_s3_metric_ax[0].set_title(\"Točnost po epohama\")\nt4_s3_metric_ax[0].set_xlabel(\"Epohe\")\nt4_s3_metric_ax[0].set_ylabel(\"%\")\n\nt4_s3_metric_ax[0].plot(range(len(t4_s3_results_tr[\"acc\"])),\n [x * 100 for x in t4_s3_results_tr[\"acc\"]],\n label=\"Točnost učenja\",\n marker=\"o\")\nt4_s3_metric_ax[0].plot(range(len(t4_s3_results_val[\"acc\"])),\n [x * 100 for x in t4_s3_results_val[\"acc\"]],\n label=\"Točnost validacije\",\n marker=\"o\")\n\n\nt4_s3_metric_ax[1].set_title(\"F1-mjera po epohama\")\nt4_s3_metric_ax[1].set_xlabel(\"Epohe\")\nt4_s3_metric_ax[1].set_ylabel(\"%\")\n\nt4_s3_metric_ax[1].plot(range(len(t4_s3_results_tr[\"f1\"])),\n [x * 100 for x in t4_s3_results_tr[\"f1\"]],\n label=\"F1-mjera učenja\",\n marker=\"o\")\nt4_s3_metric_ax[1].plot(range(len(t4_s3_results_val[\"f1\"])),\n [x * 100 for x in t4_s3_results_val[\"f1\"]],\n label=\"F1-mjera validacije\",\n marker=\"o\")\n\n\nt4_s3_tr_metric_ax[0].set_title(\"Unakrsna entropija po epohama\")\nt4_s3_tr_metric_ax[0].set_xlabel(\"Epohe\")\nt4_s3_tr_metric_ax[0].set_ylabel(\"Gubitak\")\n\nt4_s3_tr_metric_ax[0].plot(range(len(t4_s3_results_tr[\"loss\"])),\n t4_s3_results_tr[\"loss\"],\n label=\"Gubitak učenja\",\n marker=\"o\")\nt4_s3_tr_metric_ax[0].plot(range(len(t4_s3_results_val[\"loss\"])),\n t4_s3_results_val[\"loss\"],\n label=\"Gubitak validacije\",\n marker=\"o\")\n\n\nt4_s3_tr_metric_ax[1].set_title(\"Stopa učenja po epohama\")\nt4_s3_tr_metric_ax[1].set_xlabel(\"Epohe\")\nt4_s3_tr_metric_ax[1].set_ylabel(\"Stopa učenja\")\nt4_s3_tr_metric_ax[1].set_yscale(\"log\")\n\nt4_s3_tr_metric_ax[1].plot(range(len(t4_s3_learning_rates)),\n t4_s3_learning_rates,\n label=\"Stopa učenja\",\n marker=\"o\")\n\nfor i in range(2):\n t4_s3_metric_ax[i].legend()\n t4_s3_tr_metric_ax[i].legend()\n```\n\n**Komentar**:\n\nGornji red grafova dijeli y-os (jer se radi o metrikama koje su koliko-toliko srodne). Primijetite da donji desni graf ima logaritamsku y-os.\n\n### Podzadatak 4\n\nVizualizirajte slučajno inicijalizirane težine konvolucijskog sloja.\n\n**Odgovor**:\n\nPrikazat ćemo prvi konvolucijski sloj na početku učenja (nasumično inicijaliziran) i na kraju učenja:\n\n\n```python\nt4_s4_image_names = sorted([x for x in os.listdir(t4_root_path) if x.endswith(\".png\")],\n key=lambda x: x.lower())\nt4_first_last = t4_s4_image_names[0], t4_s4_image_names[-1]\n```\n\n\n```python\nt4_s4_figure, t4_s4_axes = plt.subplots(1, 2, figsize=(16, 8))\n\nfor i, (image_name, title) in enumerate(zip(t4_first_last,\n [\"Početak učenja\", \"Kraj učenja\"])):\n t4_s4_axes[i].imshow(plt.imread(os.path.join(t4_root_path, image_name)), interpolation=\"nearest\")\n t4_s4_axes[i].set_title(title)\n t4_s4_axes[i].axis(\"off\")\n```\n\n**Komentar**:\n\nJako je teško vidjeti razliku ova dva sloja. Razlog za to je što smo koristili grupnu normalizaciju (engl. *batch normalization*), pa nam L2 regularizacija nije bila potrebna. No, zbog toga što grupna normalizacija ne sređuje težine, već ima svoje parametre koje utječu na podatke koji protječu kroz mrežu, taj utjecaj nije vidljiv u samim filtrima 1. konvolucijskog sloja, već bi se nad njim trebala napraviti transformacija koja bi onda bila ekvivalentna 1. filtru konvolucijskog sloja **bez** grupne normalizacije.\n\nIzrada takve transformacije je izvan okvira ove vježbe.\n\n### Podzadatak 5\n\nPrikažite $20$ netočno klasificiranih slika s najvećim gubitkom te ispišite njihov točan razred, kao i $3$ razreda za koje je model dao najveću vjerojatnost.\n\n**Odgovor**:\n\nOvo ćemo postići koristeći metodu `analyze_evaluation` u modulu `task_4.py`. Također, prije snimanja normalizirat ćemo slike po uputama. To možemo učiniti koristeći rječnik koji nam vraća metoda `prepare_CIFAR` jer će ona vratiti rječnik s unosima `mean` i `std` koji predstavljaju očekivanu vrijednost i standardnu devijaciju.\n\nPrvo moramo učitati model i prebaciti ga u mod evaluacije:\n\n\n```python\nt4_s5_model = torch.load(t4_model_path)\nt4_s5_model.eval();\n```\n\nZatim možemo pozvati `analyze_evaluation` nad njim i testnim skupom (testni skup je 3. član trojke koje vraća metoda `prepare_CIFAR` za `x` i `y`:\n\n\n```python\nanalyze_evaluation(model=t4_s5_model,\n x=t4_s2_cifar_dict[\"x\"][2],\n y=t4_s2_cifar_dict[\"y\"][2],\n mean=t4_s2_cifar_dict[\"mean\"],\n std=t4_s2_cifar_dict[\"std\"])\n```\n\n 100%|██████████| 10000/10000 [00:00<00:00, 67816.98it/s]\n\n\nImena labela nalaze se u listi `cifar_labels`. Pomoću njih možemo prikazati $20$ najgorih slika:\n\n\n```python\nwith open(t4_s5_best_classes_path) as file:\n t4_s5_best_classes = json.load(file)\n \nwith open(t4_s5_worst_classes_path) as file:\n t4_s5_worst_classes = json.load(file)\n```\n\n\n```python\nt4_s5_n_cols = 5\nt4_s5_figure, t4_s5_axes = plt.subplots(20 // t4_s5_n_cols, t4_s5_n_cols, figsize=(14, 12))\n\nfor i, image_path in enumerate(sorted([x for x in os.listdir(t4_s5_path) if x.endswith(\".png\")])):\n a = i // t4_s5_n_cols\n b = i % t4_s5_n_cols\n\n t4_s5_axes[a][b].imshow(plt.imread(os.path.join(t4_s5_path, image_path)), interpolation=\"nearest\")\n t4_s5_axes[a][b].set_title(f\"{cifar_labels[t4_s5_worst_classes[i][1]]} \" +\\\n f\"umjesto {cifar_labels[t4_s5_worst_classes[i][0]]}\")\n t4_s5_axes[a][b].axis(\"off\")\n t4_s5_axes[a][b].title.set_fontsize(10)\n```\n\n**Komentar**:\n\nVidimo da je klasifikator najnesigurniji za neke nejednoznačne slike. Neke slike je teško opravdati kao pogreške:\n- $7$ (Zrakoplov umjesto Mačka)\n- $9$ (Automobil umjesto Ptica)\n- $12$ (Ptica umjesto Jelen)\n- $13$ (Jelen umjesto Ptica)\n- $15$ (Pas umjesto Konj)\n\nKod ovih slika bi vjerojatno pomogao veći raspon rezolucija jer se radi o slikama koje objekt prikazuju iz blizine, dakle u detaljima koji se vjerojatno veći nega za ostatak slika.\n\nFinalno, prikazat ćemo $3$ razreda za koje mreža najbolje rasuđuje:\n\n\n```python\nt4_t5_display = f\"
Mreža najtočnije rasuđuje sljedeće razrede:\\n\"\n\nfor class_id, prob in t4_s5_best_classes:\n t4_t5_display += f\"- **{cifar_labels[class_id]}**: {prob * 100:.02f}%\\n\"\n \nMarkdown(t4_t5_display)\n```\n\n\n\n\n
Mreža najtočnije rasuđuje sljedeće razrede:\n- **Automobil**: 85.80%\n- **Brod**: 85.40%\n- **Kamion**: 83.80%\n\n\n\n", "meta": {"hexsha": "667b3dd141f714466b12ea4cf37f5af77d7f8db3", "size": 389502, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "LAB2/LAB2.ipynb", "max_stars_repo_name": "Yalfoosh/DUBUCE", "max_stars_repo_head_hexsha": "3f53923c27b1bce0ac592b20c5bb98649cb7fb75", "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": "LAB2/LAB2.ipynb", "max_issues_repo_name": "Yalfoosh/DUBUCE", "max_issues_repo_head_hexsha": "3f53923c27b1bce0ac592b20c5bb98649cb7fb75", "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": "LAB2/LAB2.ipynb", "max_forks_repo_name": "Yalfoosh/DUBUCE", "max_forks_repo_head_hexsha": "3f53923c27b1bce0ac592b20c5bb98649cb7fb75", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-23T02:06:47.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-23T02:06:47.000Z", "avg_line_length": 225.1456647399, "max_line_length": 128772, "alphanum_fraction": 0.890547417, "converted": true, "num_tokens": 9601, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44939263446475963, "lm_q2_score": 0.17106119167858438, "lm_q1q2_score": 0.07687363958312025}}
{"text": "# A short & practical introduction to Tensor Flow!\n\nPart 4\n\nThe goal of this notebook is to train a LSTM character prediction model over [Text8](http://mattmahoney.net/dc/textdata) data.\n\nThis is a personal wrap-up of all the material provided by [Google's Deep Learning course on Udacity](https://www.udacity.com/course/deep-learning--ud730), so all credit goes to them. \n\nAuthor: Pablo M. Olmos (olmos@tsc.uc3m.es)\n\n** This notebook cerntainly needs more comments to make it self-contained**\n\nDate: March 2017\n\n\n```python\n# These are all the modules we'll be using later. Make sure you can import them\n# before proceeding further.\nfrom __future__ import print_function\nimport os\nimport numpy as np\nimport random\nimport string\nimport tensorflow as tf\nimport zipfile\nfrom six.moves import range\nfrom six.moves.urllib.request import urlretrieve\n```\n\n\n```python\n# Lets check what version of tensorflow we have installed. The provided scripts should run with tf 1.0 and above\n\nprint(tf.__version__)\n```\n\n 1.3.0\n\n\n\n```python\nurl = 'http://mattmahoney.net/dc/'\n\ndef maybe_download(filename, expected_bytes):\n \"\"\"Download a file if not present, and make sure it's the right size.\"\"\"\n if not os.path.exists(filename):\n filename, _ = urlretrieve(url + filename, filename)\n statinfo = os.stat(filename)\n if statinfo.st_size == expected_bytes:\n print('Found and verified %s' % filename)\n else:\n print(statinfo.st_size)\n raise Exception(\n 'Failed to verify ' + filename + '. Can you get to it with a browser?')\n return filename\n\n\nfilename = maybe_download('../../DataSets/textWordEmbeddings/text8.zip', 31344016) ## Change according to the folder where you saved the dataset provided\n```\n\n Found and verified ../../DataSets/textWordEmbeddings/text8.zip\n\n\n\n```python\ndef read_data(filename):\n with zipfile.ZipFile(filename) as f:\n name = f.namelist()[0]\n data = tf.compat.as_str(f.read(name))\n return data\n \ntext = read_data(filename)\nprint('Data size %d' % len(text))\n```\n\n Data size 100000000\n\n\n\n```python\ntext[0:20]\n```\n\n\n\n\n ' anarchism originate'\n\n\n\nCreate a small validation set\n\n\n```python\nvalid_size = 1000\nvalid_text = text[:valid_size]\ntrain_text = text[valid_size:]\ntrain_size = len(train_text)\nprint(train_size, train_text[:64])\nprint(valid_size, valid_text[:64])\n```\n\n 99999000 ons anarchists advocate social relations based upon voluntary as\n 1000 anarchism originated as a term of abuse first used against earl\n\n\nUtility functions to map characters to vocabulary IDs and back\n\n\n```python\nvocabulary_size = len(string.ascii_lowercase) + 1 # [a-z] + ' '\nfirst_letter = ord(string.ascii_lowercase[0])\n\ndef char2id(char):\n if char in string.ascii_lowercase:\n return ord(char) - first_letter + 1\n elif char == ' ':\n return 0\n else:\n print('Unexpected character: %s' % char)\n return 0\n```\n\n\n```python\ndef id2char(dictid):\n if dictid > 0:\n return chr(dictid + first_letter - 1)\n else:\n return ' '\n \nprint(char2id('a'), char2id('z'), char2id(' '), char2id('ï'))\nprint(id2char(1), id2char(26), id2char(0))\n```\n\n Unexpected character: ï\n 1 26 0 0\n a z \n\n\nFunction to generate a training batch for the LSTM model.\n\n\n```python\nbatch_size=64 ## Number of batches, but also number of segments in which we divide the text. We read batch_size \n ## batches in parallel, each read from a different segment. The implementation is not obvious, the\n ## key seems to be the zip function inside the for loop below\n \nnum_unrollings=10 ## Each sequence is num_unrolling character long\n\n### NOW I GET IT!! Every batch is a batch_size times 27 (num letters) matrix. Every row correspond to a letter. Each letter \n### comes from a different sequence of (num_unrollings) so that the 64 letters cannot be read together.\n## In the next batch, we have the following letter for each of the 64 training sequences!!\n\nclass BatchGenerator(object):\n \n def __init__(self, text, batch_size, num_unrollings):\n self._text = text\n self._text_size = len(text)\n self._batch_size = batch_size\n self._num_unrollings = num_unrollings\n segment = self._text_size // batch_size #We split the text into batch_size pieces\n self._cursor = [ offset * segment for offset in range(batch_size)] #Cursor pointing every piece\n self._last_batch = self._next_batch()\n \n #\n def _next_batch(self):\n \"\"\"Generate a single batch from the current cursor position in the data.\"\"\"\n batch = np.zeros(shape=(self._batch_size, vocabulary_size), dtype=np.float)\n for b in range(self._batch_size):\n batch[b, char2id(self._text[self._cursor[b]])] = 1.0 #One hot encoding\n #print(self._text[self._cursor[b]])\n self._cursor[b] = (self._cursor[b] + 1) % self._text_size\n return batch\n \n def next(self):\n \"\"\"Generate the next array of batches from the data. The array consists of\n the last batch of the previous array, followed by num_unrollings new ones.\n \"\"\"\n batches = [self._last_batch]\n for step in range(self._num_unrollings):\n batches.append(self._next_batch())\n self._last_batch = batches[-1]\n return batches\n \n \ndef characters(probabilities):\n \"\"\"Turn a 1-hot encoding or a probability distribution over the possible\n characters back into its (mostl likely) character representation.\"\"\"\n return [id2char(c) for c in np.argmax(probabilities, 1)]\n\ndef batches2string(batches):\n \"\"\"Convert a sequence of batches back into their (most likely) string\n representation.\"\"\"\n s = [''] * batches[0].shape[0]\n for b in batches:\n s = [''.join(x) for x in zip(s, characters(b))] #Clever! The ZIP is the key function here!\n return s \n\ntrain_batches = BatchGenerator(train_text, batch_size, 10)\nvalid_batches = BatchGenerator(valid_text, 1, 1)\n\n\n```\n\n\n```python\nprint(batches2string(train_batches.next()))\nprint(batches2string(train_batches.next()))\n```\n\n ['ons anarchi', 'when milita', 'lleria arch', ' abbeys and', 'married urr', 'hel and ric', 'y and litur', 'ay opened f', 'tion from t', 'migration t', 'new york ot', 'he boeing s', 'e listed wi', 'eber has pr', 'o be made t', 'yer who rec', 'ore signifi', 'a fierce cr', ' two six ei', 'aristotle s', 'ity can be ', ' and intrac', 'tion of the', 'dy to pass ', 'f certain d', 'at it will ', 'e convince ', 'ent told hi', 'ampaign and', 'rver side s', 'ious texts ', 'o capitaliz', 'a duplicate', 'gh ann es d', 'ine january', 'ross zero t', 'cal theorie', 'ast instanc', ' dimensiona', 'most holy m', 't s support', 'u is still ', 'e oscillati', 'o eight sub', 'of italy la', 's the tower', 'klahoma pre', 'erprise lin', 'ws becomes ', 'et in a naz', 'the fabian ', 'etchy to re', ' sharman ne', 'ised empero', 'ting in pol', 'd neo latin', 'th risky ri', 'encyclopedi', 'fense the a', 'duating fro', 'treet grid ', 'ations more', 'appeal of d', 'si have mad']\n ['ists advoca', 'ary governm', 'hes nationa', 'd monasteri', 'raca prince', 'chard baer ', 'rgical lang', 'for passeng', 'the nationa', 'took place ', 'ther well k', 'seven six s', 'ith a gloss', 'robably bee', 'to recogniz', 'ceived the ', 'icant than ', 'ritic of th', 'ight in sig', 's uncaused ', ' lost as in', 'cellular ic', 'e size of t', ' him a stic', 'drugs confu', ' take to co', ' the priest', 'im to name ', 'd barred at', 'standard fo', ' such as es', 'ze on the g', 'e of the or', 'd hiver one', 'y eight mar', 'the lead ch', 'es classica', 'ce the non ', 'al analysis', 'mormons bel', 't or at lea', ' disagreed ', 'ing system ', 'btypes base', 'anguages th', 'r commissio', 'ess one nin', 'nux suse li', ' the first ', 'zi concentr', ' society ne', 'elatively s', 'etworks sha', 'or hirohito', 'litical ini', 'n most of t', 'iskerdoo ri', 'ic overview', 'air compone', 'om acnm acc', ' centerline', 'e than any ', 'devotional ', 'de such dev']\n\n\n\n```python\n#OK with this one\ndef logprob(predictions, labels):\n \"\"\"Log-probability of the true labels in a predicted batch.\"\"\"\n predictions[predictions < 1e-10] = 1e-10\n return np.sum(np.multiply(labels, -np.log(predictions))) / labels.shape[0]\n\n#OK with this one\ndef sample_distribution(distribution):\n \"\"\"Sample one element from a distribution assumed to be an array of normalized\n probabilities.\n \"\"\"\n \n r = random.uniform(0,1)\n s = 0\n for i in range(len(distribution)):\n s += distribution[i]\n if s >= r:\n return i\n return len(distribution) - 1\n\n#OK with this one\ndef sample(prediction):\n \"\"\"Turn a (column) prediction into 1-hot encoded samples.\"\"\"\n p = np.zeros(shape=[1, vocabulary_size], dtype=np.float)\n p[0, sample_distribution(prediction[0])] = 1.0\n return p\n\n\ndef random_distribution():\n \"\"\"Generate a random column of probabilities.\"\"\"\n b = np.random.uniform(0.0, 1.0, size=[1, vocabulary_size])\n return b / np.sum(b, 1)[:, None]\n\n```\n\n\n```python\ntrain_batches.next()[0].shape\n```\n\n\n\n\n (64, 27)\n\n\n\n# Simple LSTM Model\n\nRecall the fundamental model\n\n\n\n\nAlso, the un-regularized cost function is\n\n\\begin{align}\nJ(\\boldsymbol{\\theta})=\\frac{1}{N}\\sum_{n=1}^N\\sum_{t=1}^{T_n}d(\\boldsymbol{y}_t^{(n)},\\sigma(\\boldsymbol{h}_t^{(n)}))\n\\end{align}\nwhere $d(\\cdot,\\cdot)$ is the cross-entropy loss function.\n\nAbout the TF implementation below, see the following excellent [post](http://www.thushv.com/sequential_modelling/long-short-term-memory-lstm-networks-implementing-with-tensorflow-part-2/)\n\n> \nNow calculating logits for softmax is a little bit tricky. This a temporal (time-based) network. So after each processing each num_unrolling batches through the LSTM cell, we update h_{t-1}=h_t and c_{t-1}=c_t before calculating logits and the loss. This is done by using tf.control_dependencies. What this does is that, logits will not be calculated until saved_output and saved_states are updated. Finally, as you can see, num_unrolling acts as the amount of history we are remembering.\n\nIn other words, in the computation graph everytime something is updated, all the dependent op nodes are updated and this is propagated through the graph. If we want to wait until the very end to compute the loss, we wait using the command tf.control_dependencies.\n\nAbout the zip() and zip(*) operators, see this [post](https://docs.python.org/2/library/functions.html#zip)\n\n\n```python\nnum_nodes = 64\n\ngraph = tf.Graph()\nwith graph.as_default():\n \n # Parameters:\n \n #i(t) parameters\n # Input gate: input, previous output, and bias.\n ix = tf.Variable(tf.truncated_normal([vocabulary_size, num_nodes], -0.1, 0.1)) ##W^ix\n im = tf.Variable(tf.truncated_normal([num_nodes, num_nodes], -0.1, 0.1)) ## W^ih\n ib = tf.Variable(tf.zeros([1, num_nodes])) ##b_i\n \n #f(t) parameters\n # Forget gate: input, previous output, and bias.\n fx = tf.Variable(tf.truncated_normal([vocabulary_size, num_nodes], -0.1, 0.1)) ##W^fx\n fm = tf.Variable(tf.truncated_normal([num_nodes, num_nodes], -0.1, 0.1)) ##W^fh\n fb = tf.Variable(tf.zeros([1, num_nodes])) ##b_f\n \n #g(t) parameters\n # Memory cell: input, state and bias. \n cx = tf.Variable(tf.truncated_normal([vocabulary_size, num_nodes], -0.1, 0.1)) ##W^gx\n cm = tf.Variable(tf.truncated_normal([num_nodes, num_nodes], -0.1, 0.1)) ##W^gh\n cb = tf.Variable(tf.zeros([1, num_nodes])) ##b_g\n \n #o(t) parameters\n # Output gate: input, previous output, and bias.\n ox = tf.Variable(tf.truncated_normal([vocabulary_size, num_nodes], -0.1, 0.1)) ##W^ox\n om = tf.Variable(tf.truncated_normal([num_nodes, num_nodes], -0.1, 0.1)) ##W^oh\n ob = tf.Variable(tf.zeros([1, num_nodes])) ##b_o\n \n # Variables saving state across unrollings.\n saved_output = tf.Variable(tf.zeros([batch_size, num_nodes]), trainable=False) #h(t)\n saved_state = tf.Variable(tf.zeros([batch_size, num_nodes]), trainable=False) #s(t)\n \n \n # Classifier weights and biases (over h(t) to labels)\n w = tf.Variable(tf.truncated_normal([num_nodes, vocabulary_size], -0.1, 0.1))\n b = tf.Variable(tf.zeros([vocabulary_size]))\n \n # Definition of the cell computation.\n def lstm_cell(i, o, state):\n \"\"\"Create a LSTM cell. See e.g.: http://arxiv.org/pdf/1402.1128v1.pdf\n Note that in this formulation, we omit the various connections between the\n previous state and the gates.\"\"\"\n input_gate = tf.sigmoid(tf.matmul(i, ix) + tf.matmul(o, im) + ib)\n forget_gate = tf.sigmoid(tf.matmul(i, fx) + tf.matmul(o, fm) + fb)\n update = tf.matmul(i, cx) + tf.matmul(o, cm) + cb \n state = forget_gate * state + input_gate * tf.tanh(update) #tf.tanh(update) is g(t)\n output_gate = tf.sigmoid(tf.matmul(i, ox) + tf.matmul(o, om) + ob)\n return output_gate * tf.tanh(state), state #h(t) is output_gate * tf.tanh(state)\n\n # Input data. Now it makes sense!!!\n \n train_data = list()\n for _ in range(num_unrollings + 1):\n train_data.append(tf.placeholder(tf.float32, shape=[batch_size,vocabulary_size]))\n train_inputs = train_data[:num_unrollings]\n train_labels = train_data[1:] # labels are inputs shifted by one time step.\n\n # Unrolled LSTM loop.\n \n outputs = list()\n output = saved_output\n aux = output\n state = saved_state\n for i in train_inputs:\n output, state = lstm_cell(i, output, state)\n outputs.append(output)\n\n # State saving across unrollings.\n with tf.control_dependencies([saved_output.assign(output),saved_state.assign(state)]):\n #Classifier.\n logits = tf.nn.xw_plus_b(tf.concat(axis=0,values=outputs), w, b)\n loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=tf.concat(axis=0, values=train_labels),logits=logits))\n\n # Optimizer.\n \n \"\"\"Next, we are implementing the optimizer. Remember! we should use “gradient clipping” (tf.clip_by_global_norm) \n to avoid “Exploding gradient” phenomenon. Also, we decay the learning_rate over time.\"\"\"\n global_step = tf.Variable(0)\n \n learning_rate = tf.train.exponential_decay(10.0, global_step, 5000, 0.1, staircase=True)\n optimizer = tf.train.GradientDescentOptimizer(learning_rate)\n \n \"\"\" optimizer.compute_gradients(loss) yields (gradient, value) tuples. gradients, v = zip(*optimizer.compute_gradients(loss))\n performs a transposition, creating a list of gradients and a list of values.\n gradients, _ = tf.clip_by_global_norm(gradients, 1.25)\n then clips the gradients, and optimizer = optimizer.apply_gradients(zip(gradients, v), global_step=global_step)\n re-zips the gradient and value lists back into an iterable of (gradient, value) \n tuples which is then passed to the optimizer.apply_gradients method.\"\"\"\n \n gradients, v = zip(*optimizer.compute_gradients(loss))\n gradients, _ = tf.clip_by_global_norm(gradients, 1.25)\n optimizer = optimizer.apply_gradients(zip(gradients, v), global_step=global_step)\n\n # Predictions.\n train_prediction = tf.nn.softmax(logits)\n \n # Sampling and validation eval: batch 1, no unrolling.\n sample_input = tf.placeholder(tf.float32, shape=[1, vocabulary_size])\n saved_sample_output = tf.Variable(tf.zeros([1, num_nodes]))\n saved_sample_state = tf.Variable(tf.zeros([1, num_nodes]))\n # Create an op that groups multiple operations.\n reset_sample_state = tf.group(saved_sample_output.assign(tf.zeros([1, num_nodes])),\n saved_sample_state.assign(tf.zeros([1, num_nodes])))\n \n sample_output, sample_state = lstm_cell(sample_input, saved_sample_output, saved_sample_state)\n \n with tf.control_dependencies([saved_sample_output.assign(sample_output),saved_sample_state.assign(sample_state)]):\n sample_prediction = tf.nn.softmax(tf.nn.xw_plus_b(sample_output, w, b))\n\n```\n\n\n```python\nnum_steps = 1001\nsummary_frequency = 100\n\nwith tf.Session(graph=graph) as session:\n tf.global_variables_initializer().run()\n print('Initialized')\n mean_loss = 0\n for step in range(num_steps):\n batches = train_batches.next()\n feed_dict = dict()\n for i in range(num_unrollings + 1):\n feed_dict[train_data[i]] = batches[i]\n _, l, predictions, lr = session.run(\n [optimizer, loss, train_prediction, learning_rate], feed_dict=feed_dict)\n mean_loss += l\n if step % summary_frequency == 0:\n if step > 0:\n mean_loss /= summary_frequency\n # The mean loss is an estimate of the loss over the last few batches.\n print(\n 'Average loss at step %d: %f learning rate: %f' % (step, mean_loss, lr))\n mean_loss = 0\n labels = np.concatenate(list(batches)[1:])\n print('Minibatch perplexity: %.2f' % float(\n np.exp(logprob(predictions, labels))))\n if step % (summary_frequency * 10) == 0:\n # Generate some samples.\n print('=' * 80)\n for _ in range(5):\n feed = sample(random_distribution())\n sentence = characters(feed)[0]\n reset_sample_state.run()\n for _ in range(79):\n prediction = sample_prediction.eval({sample_input: feed})\n feed = sample(prediction)\n sentence += characters(feed)[0]\n print(sentence)\n print('=' * 80)\n # Measure validation set perplexity.\n reset_sample_state.run()\n valid_logprob = 0\n for _ in range(valid_size):\n b = valid_batches.next()\n predictions = sample_prediction.eval({sample_input: b[0]})\n valid_logprob = valid_logprob + logprob(predictions, b[1])\n print('Validation set perplexity: %.2f' % float(np.exp(\n valid_logprob / valid_size)))\n```\n\n Initialized\n Average loss at step 0: 3.294209 learning rate: 10.000000\n Minibatch perplexity: 26.96\n ================================================================================\n mxovr oqde yfxkdo lgo slt r jyl uqoizrtvtz rozih o giopvwtirvvfji ioisixishdut\n rteew vmekfznhts utnotduqtnvitnip niki eb e pv dbopsfvpm el ittceecbnryravioe j\n ltvbgee kzaauloap jdlvnh vthfvkvqtisnr oqnr yc gs om icihhdfriiaradwnooezke v c\n b zowgrzzlfsfin qtpnbleqteoiss pf tta jn wd ohsv zgwsictzraulredxokf os ev qwab\n lpeottcin ffinel hxcylubmceenohedvin cm nbp tednlatrxipat yqvwnosbgnlwmviaeruox\n ================================================================================\n Validation set perplexity: 20.10\n Average loss at step 100: 2.598391 learning rate: 10.000000\n Minibatch perplexity: 10.37\n Validation set perplexity: 10.75\n Average loss at step 200: 2.253659 learning rate: 10.000000\n Minibatch perplexity: 9.72\n Validation set perplexity: 9.11\n Average loss at step 300: 2.097530 learning rate: 10.000000\n Minibatch perplexity: 7.71\n Validation set perplexity: 7.79\n Average loss at step 400: 1.997222 learning rate: 10.000000\n Minibatch perplexity: 7.69\n Validation set perplexity: 7.62\n Average loss at step 500: 1.932652 learning rate: 10.000000\n Minibatch perplexity: 6.26\n Validation set perplexity: 7.12\n Average loss at step 600: 1.907986 learning rate: 10.000000\n Minibatch perplexity: 6.14\n Validation set perplexity: 6.84\n Average loss at step 700: 1.857451 learning rate: 10.000000\n Minibatch perplexity: 5.60\n Validation set perplexity: 6.70\n Average loss at step 800: 1.818764 learning rate: 10.000000\n Minibatch perplexity: 6.20\n Validation set perplexity: 6.71\n Average loss at step 900: 1.830710 learning rate: 10.000000\n Minibatch perplexity: 7.22\n Validation set perplexity: 6.35\n Average loss at step 1000: 1.824062 learning rate: 10.000000\n Minibatch perplexity: 5.82\n ================================================================================\n h is notsowifs wite is engliaily hurds ninekture that finch ebord of pearist sub\n riced frvmic in in hidu of the ind d finlibul the leate and nothorlod and trever\n pily hlil and ros is inferrick in llils thhirai erlic brozg o redortining clihe \n s in the vire of the ifterible frog kid a and will priling madiep precents to so\n c lith severneric sever fill listration of the impress jo the mycri five zeres c\n ================================================================================\n Validation set perplexity: 6.17\n\n\n\n```python\nbatches = train_batches.next()\n```\n\n\n```python\nbatches[0]\n```\n\n\n\n\n array([[ 0., 0., 0., ..., 0., 0., 0.],\n [ 0., 0., 0., ..., 0., 0., 1.],\n [ 0., 0., 0., ..., 0., 0., 0.],\n ..., \n [ 0., 0., 0., ..., 0., 0., 0.],\n [ 0., 0., 0., ..., 0., 0., 0.],\n [ 0., 0., 0., ..., 0., 0., 0.]])\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "7f36570c191a510c86fb8c85f0b87af2085f2970", "size": 29011, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Notebooks/Part_4/LSTMs.ipynb", "max_stars_repo_name": "olmosUC3M/Introduction-to-Tensor-Flow-and-Deep-Learning", "max_stars_repo_head_hexsha": "3d173606f273f6b3e2bf3cbdccea1c4fe59af71f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-03-05T14:19:15.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-13T23:53:08.000Z", "max_issues_repo_path": "Notebooks/Part_4/LSTMs.ipynb", "max_issues_repo_name": "olmosUC3M/Introduction-to-Tensor-Flow-and-Deep-Learning", "max_issues_repo_head_hexsha": "3d173606f273f6b3e2bf3cbdccea1c4fe59af71f", "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/Part_4/LSTMs.ipynb", "max_forks_repo_name": "olmosUC3M/Introduction-to-Tensor-Flow-and-Deep-Learning", "max_forks_repo_head_hexsha": "3d173606f273f6b3e2bf3cbdccea1c4fe59af71f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-03-31T20:26:47.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-31T20:26:47.000Z", "avg_line_length": 39.5784447476, "max_line_length": 971, "alphanum_fraction": 0.552238806, "converted": true, "num_tokens": 5669, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4921881357207955, "lm_q2_score": 0.15610490333452268, "lm_q1q2_score": 0.0768329813490937}}
{"text": "# Nuclear Fuel Fabrication\n\nNuclear fuel production is a highly constrained and optimized process.\n\n## Learning Objectives\n\n- Differentiate fuel characteristics and materials in various reactor designs \n- List safety constraints driving fuel designs\n- Order the steps in PWR UOx fuel fabrication\n- Explain the role of fuel and cladding in providing a barrier to radionuclide release\n- Name appropriate criteria for selection of cladding materials\n- Compare the mechanims of typical fuel failures\n- Evaluate the potential costs of defects\n- Name the contributors to fuel fabrication costs\n\n\n## Safety Constraint: Controlling the Reactor\n\nControl rods and burnable poisons will be covered in detail next week in the reactor physics module. For now, note that cadmium and boron are important for managing excess reactivity because of their large absorption cross sections.\n\n\n\n\n## Safety Constraint: Containing the Fission Products\n\n\n\n\n## CANDU\n\n\n- natural uranium\n- heavy water ($D_2O$)\n- online refuelling\n- each bundle: 50 cm long 10 cm diameter\n\n\n\n\n\n\n\n\n\n\n## PWR \n\n- UO2 fuel\n- Zircalloy cladding (typically)\n- Height: 4.1m\n- Hardware mostly Zircaloy (Zr with Sn, Fe, Cr)\n- Grid spacers: Zircaloy, Inconel, stainless steel\n- End pieces: Stainless steel, Inconel\n- 200-250 fuel assemblies per core\n- Each Assembly: \n - 14 x 14 to 17 x 17 fuel elements\n - 21cm x 21cm\n - Fuel element size: 1 cm diameter, \n - Fuel element height: 3.9m\n - Assembly weight: 1400lb\n - Enrichment: 3-5%\n - May have separate burnable poison rods\n \n \n \n \n \n \n\n\n```python\nrod = 400 # pellets per rod\nassembly = 17*17 - 5*5 # assembly array minus control rod tubes\ncore = 193 # typical number of assemblies per core\nprint(\"Total pellets in a core\", core*assembly*rod)\nprint(\"Total rods in a core\", core*assembly)\n```\n\n ('Total pellets in a core', 20380800)\n ('Total rods in a core', 50952)\n\n\n## BWR\n\nA BWR has about 600-800 fuel assemblies per core. Each assembly:\n\n- 14ft (4.5m) tall\n- Zircalloy channel around the assembly\n- Hardware mostly Zircaloy (Zr with Sn, Fe, Cr)\n- Grid spacers: Zircaloy\n- Channel (aka shroud): Zircaloy\n- End pieces: Stainless steel\n- Each assembly\n - 700lb\n - 5.5x5.5 inches (14 cm x 14 cm) square assembly\n - Fuel element array: 8 x 8 or 10 x 10\n - Fuel element size: 1.25 cm diameter, height = 4.1m\n - Enrichment: 2.5-4.5%\n - May have Gd in some rods and variable enrichment in 3D\n\n\n\n\n### Zircalloy\n\nThere is a phenomenal review paper called \"Selection of fuel cladding material for nuclear fission reactors.\" https://www.researchgate.net/publication/257519826_Selection_of_fuel_cladding_material_for_nuclear_fission_reactors . Many of the following images come directly from that paper.\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n# PWR Fuel Fabrication Steps\n\n\n\nThe \"pellet manufacturing\" step is somewhat complex.\n\n\n\n# Fuel Failure\n\n\nTypes of failure have changed over time and vary among reactor fuel types. The IAEA did [a comprehensive review of this topic recently.](http://www-pub.iaea.org/MTCD/Publications/PDF/Pub1445_web.pdf). In it, the following causes of fuel failure were noted:\n\n- Debris (particularly in BWRs)\n- Pellet-Cladding Interaction \n- Grid to Rod Fretting (particularly in PWRs)\n- Fuel Handling Incidents\n- Crud and Corrosion\n\n## Modeling of Failure\n\n\\begin{align}\nR &= r\\times\\frac{D}{N}\\\\ \n\\mbox{where}&\\\\\nR&=\\mbox{ an annual rod failure rate (leaking rods/rods in core)}\\\\\nN &= \\mbox{ the number of rods in core for all operating reactors with or without refuelling in the respective year}\\\\\nD &=\\mbox{ the number of leaking assemblies found and discharged from all operating reactors in a year}\\\\\nr &=\\mbox{ the average number of leaking rods per leaking assembly}\\\\\n\\end{align}\n\nThe rate, r, according to IAEA, is equal to 1.1 for BWR, WWER-440 and CANDU fuel, and 1.3 for PWR and WWER-1000 fuel.\n\n\n \n\n\n\n```python\ndef rate(r, d, n):\n return r*d/n\n\nr = 1.3 # pwr/wwer\nn = 17*17*200*213 # 213 pwr type reactors in the study\nd = 6\nprint(rate(r,d,n))\n\n```\n\n 6.33559140309e-07\n\n\n\n\n\n\n \n\n\n\n\n\n\n\n\n## Debris\n\n### Discussion: Filters can help with debris, but what other effects do they have on the reactor?\n\n\n\n## PCI \n\nThe following summary is from [an OECD report on PCI:](https://www.oecd-nea.org/science/pubs/2005/6004-pellet-clad.pdf)\n\n> Fuel and pellet behaviour mechanisms activated in PCI situations\n> \n> The behaviour of pellets in the interaction depends on many mechanisms potentially activated prior to, or during PCI, namely:\n> \n> - Densification/solid fission products and gaseous swelling under irradiation.\n> - Release of fission gases and volatile species.\n> - Evolution of thermal conductivity, elasticity constants, thermal and irradiation creep, temperature-induced or microstructure-induced phenomena (porosities, re-crystallisation).\n> - Geometry of the pellets and their modifications by cracking. \n> \n> As concerns the clad:\n> \n> - Evolution of elasticity, plasticity, creep parameters (irradiation, temperature-induced).\n> - Dependence on the microstructure and manufacturing process and its evolution under fluence.\n> - Oxidation, hydridation.\n> - Sensitivity to stress corrosion-cracking.\n> \n> As concerns the interface:\n> - Formation of contact materials or bonding layers: zirconia/uranate compound including fission products.\n> - Friction. \n\nIncreased burnups lead to higher cladding failure rates.\n\n\n\n\n
\n\n\\begin{align}\n\\large population_t &\\large= population_{t-1} + {\\Delta population} \\quad \\textrm{(sheep)} \\tag{1} \\\\\n\\large food_t &\\large= food_{t-1} + {\\Delta food} \\quad \\textrm{(tons of grass)} \\tag{2}\n\\end{align}\n\nwhere the rate of change ($\\Delta$) is:\n\\begin{align}\n\\large {\\Delta population} &\\large= \\alpha * food_{t-1} - \\epsilon * population_{t-1} \\quad \\textrm{(sheep/month)} \\\\\n\\large {\\Delta food} &\\large= -\\beta * population_{t-1} + \\gamma \\quad \\textrm{(tons of grass/month)}\n\\end{align}\n\nwhere:\n\n$\n\\begin{align}\n\\alpha: \\quad &\\textrm{'reproduction_rate'}\\\\\n\\epsilon: \\quad &\\textrm{'death_rate'}\\\\\n\\beta: \\quad &\\textrm{'consumption_rate'}\\\\\n\\gamma: \\quad &\\textrm{'growth_rate'}\\\\\n\\end{align}\n$\n\n* A population consumes a food source, and reproduces at a rate proportional to the food source $\\alpha$ (alpha), and dies at a rate proportional to the population size $\\epsilon$ (epsilon).\n* The food source is consumed at a rate proportional to the population $\\beta$ (beta), and grows at a constant rate $\\gamma$ (gamma).\n\n
\n# Well done!\n
\n", "meta": {"hexsha": "8decb645d00c2e980d9c45e5ef94a1dd1835c651", "size": 39467, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "complete-foundations-bootcamp-output-main/content/section-5-modelling-and-simulation/notebook.ipynb", "max_stars_repo_name": "redditech/cadCad-training", "max_stars_repo_head_hexsha": "a1ab040e9baf1863a75b2c85cb3ea567049b6c2a", "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": "complete-foundations-bootcamp-output-main/content/section-5-modelling-and-simulation/notebook.ipynb", "max_issues_repo_name": "redditech/cadCad-training", "max_issues_repo_head_hexsha": "a1ab040e9baf1863a75b2c85cb3ea567049b6c2a", "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": "complete-foundations-bootcamp-output-main/content/section-5-modelling-and-simulation/notebook.ipynb", "max_forks_repo_name": "redditech/cadCad-training", "max_forks_repo_head_hexsha": "a1ab040e9baf1863a75b2c85cb3ea567049b6c2a", "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.6488858879, "max_line_length": 296, "alphanum_fraction": 0.5443281729, "converted": true, "num_tokens": 5156, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.1540575588075327, "lm_q1q2_score": 0.07642700430777027}}
{"text": "# KVLCC2 Model tests vs. Ikeda and SI\n\n# Purpose\nComparison between damping coefficients (with and without speed) from model tests and predictions with Ikeda and Simplified Ikeda (SI).\n\n# Methodology\nQuickly describe assumptions and processing steps.\n\n# WIP - improvements\n(WORK IN PROGRESS)\nUse this section only if the notebook is not final.\n\nNotable TODOs:\n* todo 1\n* todo 2\n* todo 3\n\n## Results\nDescribe and comment the most important results.\n\n# Suggested next steps\nState suggested next steps, based on results obtained in this notebook.\n\n# Setup\n\n\n```python\n# %load imports.py\n\"\"\"\nThese is the standard setup for the notebooks.\n\"\"\"\n\n%matplotlib inline\n%load_ext autoreload\n%autoreload 2\n\nfrom jupyterthemes import jtplot\njtplot.style(theme='onedork', context='notebook', ticks=True, grid=False)\n\nimport pandas as pd\npd.options.display.max_rows = 999\npd.options.display.max_columns = 999\npd.set_option(\"display.max_columns\", None)\nimport numpy as np\nimport os\nimport matplotlib.pyplot as plt\nfrom collections import OrderedDict\n#plt.style.use('paper')\n\n#import data\nimport copy\nfrom mdldb.run import Run\n\nfrom sklearn.pipeline import Pipeline\nfrom rolldecayestimators.transformers import CutTransformer, LowpassFilterDerivatorTransformer, ScaleFactorTransformer, OffsetTransformer\nfrom rolldecayestimators.direct_estimator_cubic import EstimatorQuadraticB, EstimatorCubic\nfrom rolldecayestimators.ikeda_estimator import IkedaQuadraticEstimator\nimport rolldecayestimators.equations as equations\nimport rolldecayestimators.lambdas as lambdas\nfrom rolldecayestimators.substitute_dynamic_symbols import lambdify\nimport rolldecayestimators.symbols as symbols\nimport sympy as sp\n\nfrom sympy.physics.vector.printing import vpprint, vlatex\nfrom IPython.display import display, Math, Latex\n\nfrom sklearn.metrics import r2_score\nfrom src.data import database\nfrom mdldb import tables\n\n```\n\n Duplicate key in file WindowsPath('C:/Users/maa/.matplotlib/stylelib/paper.mplstyle'), line 461 ('figure.figsize : 5, 3 ## figure size in inches')\n Duplicate key in file WindowsPath('C:/Users/maa/.matplotlib/stylelib/paper.mplstyle'), line 462 ('figure.dpi : 100 ## figure dots per inch')\n\n\n\n```python\nimport pyscores2\nimport pyscores2.runScores2\nimport pyscores2.xml_hydrostatics\nfrom pyscores2.output import OutputFile\nfrom rolldecayestimators.ikeda import Ikeda, IkedaR\n\nfrom rolldecayestimators.simplified_ikeda_class import SimplifiedIkeda, SimplifiedIkedaABS\nfrom rolldecayestimators.simplified_ikeda import limits_kawahara\nfrom pyscores2.runScores2 import Calculation\nfrom pyscores2.indata import Indata\nimport joblib\nfrom scipy.optimize import least_squares\nfrom reports.paper_writing import save_fig\n```\n\n\n```python\ndb = database.get_db()\n```\n\n\n```python\nsql = \"\"\"\nSELECT * from run\nINNER JOIN loading_conditions\nON (run.loading_condition_id = loading_conditions.id)\nINNER JOIN models\nON (run.model_number = models.model_number)\nINNER JOIN ships\nON (run.ship_name = ships.name)\nWHERE run.model_number='M5057-01-A' and run.test_type='roll decay' and run.project_number=40178362;\n\"\"\"\ndf_rolldecays = pd.read_sql(sql=sql, con=db.engine)\ndf_rolldecays=df_rolldecays.loc[:,~df_rolldecays.columns.duplicated()]\ndf_rolldecays.set_index('id', inplace=True)\n\ndf_rolldecays['ship_speed'].fillna(0, inplace=True)\n\n```\n\n\n```python\ndf_rolldecays.head()\n```\n\n\n\n\n\n \n
\n\n \n \n project_number \n series_number \n run_number \n test_number \n model_number \n ship_name \n loading_condition_id \n ascii_name \n ship_speed \n comment \n file_path_ascii \n file_path_ascii_temp \n file_path_log \n file_path_hdf5 \n date \n test_type \n facility \n angle1 \n angle2 \n Körfallstyp \n name \n lcg \n kg \n gm \n CW \n TF \n TA \n BWL \n KXX \n KZZ \n BTT1 \n CP \n Volume \n A0 \n RH \n scale_factor \n lpp \n beam \n ABULB \n BKX \n TWIN \n DCLR \n VDES \n RHBL \n ASKEG \n PD \n ARH \n CFP \n AIX \n PDTDES \n RTYPE \n SFP \n BKL \n BKB \n PROT \n D \n LSKEG \n RR \n XSKEG \n NDES \n AR \n BR \n BRA \n IRUD \n PTYPE \n XRUD \n AI \n HSKEG \n RSKEG \n LOA \n ship_type_id \n \n \n \n \n id \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n 21337 \n 40178362 \n 1 \n 94 \n 1 \n M5057-01-A \n M5057-01-A \n 166 \n 94.0 \n 0.0 \n Roll decay, 0 kn \n NaN \n None \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n 2018-04-03 \n roll decay \n MDL \n None \n None \n None \n 20.8 \n 11.2672 \n 18.6 \n 5.73 \n None \n 20.8 \n 20.8 \n None \n 23.2 \n 80.0 \n None \n None \n 312653.0 \n 0.99538 \n None \n 68.0 \n 320.0 \n 58.0 \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n \n \n 21338 \n 40178362 \n 1 \n 95 \n 1 \n M5057-01-A \n M5057-01-A \n 166 \n 95.0 \n 0.0 \n Roll decay, 0 kn \n NaN \n None \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n 2018-04-03 \n roll decay \n MDL \n None \n None \n None \n 20.8 \n 11.2672 \n 18.6 \n 5.73 \n None \n 20.8 \n 20.8 \n None \n 23.2 \n 80.0 \n None \n None \n 312653.0 \n 0.99538 \n None \n 68.0 \n 320.0 \n 58.0 \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n \n \n 21339 \n 40178362 \n 1 \n 96 \n 1 \n M5057-01-A \n M5057-01-A \n 166 \n 96.0 \n 0.0 \n Roll decay, 0 kn \n NaN \n None \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n 2018-11-28 \n roll decay \n MDL \n None \n None \n None \n 20.8 \n 11.2672 \n 18.6 \n 5.73 \n None \n 20.8 \n 20.8 \n None \n 23.2 \n 80.0 \n None \n None \n 312653.0 \n 0.99538 \n None \n 68.0 \n 320.0 \n 58.0 \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n \n \n \n21340 \n 40178362 \n 1 \n 97 \n 1 \n M5057-01-A \n M5057-01-A \n 166 \n 97.0 \n 15.5 \n Roll decay, 15.5 kn \n NaN \n None \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n \\\\sspa.local\\gbg\\LABmeasuredataMDL\\40178362\\00... \n 2018-04-04 \n roll decay \n MDL \n None \n None \n None \n 20.8 \n 11.2672 \n 18.6 \n 5.73 \n None \n 20.8 \n 20.8 \n None \n 23.2 \n 80.0 \n None \n None \n 312653.0 \n 0.99538 \n None \n 68.0 \n 320.0 \n 58.0 \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n None \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n date_of_birth \n outcome_type \n outcome_subtype \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n \n \n 0 \n A808320 \n Kyha \n 2019-11-14T15:37:00.000 \n 2019-11-14T15:37:00.000 \n 2017-11-07T00:00:00.000 \n Rto-Adopt \n NaN \n Dog \n Spayed Female \n 2 years \n German Shepherd Mix \n Sable \n \n \n 1 \n A781697 \n Pookie \n 2019-11-14T15:33:00.000 \n 2019-11-14T15:33:00.000 \n 2017-10-05T00:00:00.000 \n Adoption \n NaN \n Dog \n Spayed Female \n 2 years \n Cairn Terrier \n White/Brown \n \n \n 2 \n A808382 \n NaN \n 2019-11-14T14:57:00.000 \n 2019-11-14T14:57:00.000 \n 2014-11-08T00:00:00.000 \n Transfer \n Partner \n Cat \n Intact Male \n 5 years \n Domestic Shorthair \n Orange Tabby \n \n \n 3 \n A806701 \n *Emerald \n 2019-11-14T14:41:00.000 \n 2019-11-14T14:41:00.000 \n 2019-09-02T00:00:00.000 \n Adoption \n Foster \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair \n Blue Tabby/White \n \n \n \n4 \n A804553 \n *Wendy \n 2019-11-14T14:36:00.000 \n 2019-11-14T14:36:00.000 \n 2019-08-09T00:00:00.000 \n Adoption \n Foster \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n date_of_birth \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n \n \n 59 \n A808636 \n Unknown \n 2019-11-13 13:46:00 \n 2019-11-13T13:46:00.000 \n 2004-11-11 \n Cat \n Intact Female \n NaN \n Siamese \n Seal Point \n Not adopted \n \n \n 96 \n A808702 \n Keepers \n 2019-11-12 15:20:00 \n 2019-11-12T15:20:00.000 \n 2009-11-12 \n Dog \n Neutered Male \n NaN \n Golden Retriever \n Gold \n Not adopted \n \n \n 131 \n A808649 \n Unknown \n 2019-11-11 17:49:00 \n 2019-11-11T17:49:00.000 \n 2019-10-11 \n Cat \n Intact Male \n NaN \n Domestic Shorthair \n Brown Tabby \n Not adopted \n \n \n 132 \n A738697 \n Boots \n 2019-11-11 17:48:00 \n 2019-11-11T17:48:00.000 \n 2007-11-17 \n Dog \n NaN \n NaN \n Miniature Schnauzer Mix \n Black \n Not adopted \n \n \n 161 \n A808626 \n Unknown \n 2019-11-11 13:57:00 \n 2019-11-11T13:57:00.000 \n 2019-09-11 \n Cat \n Intact Female \n NaN \n Domestic Shorthair \n Brown Tabby \n Not adopted \n \n \n 214 \n A808466 \n Unknown \n 2019-11-10 09:35:00 \n 2019-11-10T09:35:00.000 \n 2019-09-09 \n Cat \n Intact Male \n NaN \n Domestic Shorthair \n Brown/Black \n Not adopted \n \n \n 347 \n A808352 \n Unknown \n 2019-11-07 16:15:00 \n 2019-11-07T16:15:00.000 \n 2011-11-07 \n Dog \n Intact Male \n NaN \n Dachshund Mix \n Tan \n Not adopted \n \n \n \n6649 \n A752967 \n Gray \n 2019-07-24 11:42:00 \n 2019-07-24T11:42:00.000 \n 2015-06-29 \n Dog \n NaN \n NaN \n Pit Bull Mix \n Blue/White \n Not adopted \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n date_of_birth \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n \n \n 1 \n A781697 \n Pookie \n 2019-11-14 15:33:00 \n 2019-11-14T15:33:00.000 \n 2017-10-05 \n Dog \n Spayed Female \n 2 years \n Cairn Terrier \n White/Brown \n Adopted \n \n \n 2 \n A808382 \n Unknown \n 2019-11-14 14:57:00 \n 2019-11-14T14:57:00.000 \n 2014-11-08 \n Cat \n Intact Male \n 5 years \n Domestic Shorthair \n Orange Tabby \n Not adopted \n \n \n 3 \n A806701 \n *Emerald \n 2019-11-14 14:41:00 \n 2019-11-14T14:41:00.000 \n 2019-09-02 \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair \n Blue Tabby/White \n Adopted \n \n \n 4 \n A804553 \n *Wendy \n 2019-11-14 14:36:00 \n 2019-11-14T14:36:00.000 \n 2019-08-09 \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n Adopted \n \n \n \n5 \n A804552 \n *Tinkerbell \n 2019-11-14 14:35:00 \n 2019-11-14T14:35:00.000 \n 2019-08-09 \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n Adopted \n \n \n
\n\n \n \n \n \n animal_id \n name \n datetime \n monthyear \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n month_arrived \n \n \n 1 \n A781697 \n Pookie \n 2019-11-14 15:33:00 \n 2019-11-14 15:33:00 \n Dog \n Spayed Female \n 2 years \n Cairn Terrier \n White/Brown \n Adopted \n 11 \n \n \n 2 \n A808382 \n Unknown \n 2019-11-14 14:57:00 \n 2019-11-14 14:57:00 \n Cat \n Intact Male \n 5 years \n Domestic Shorthair \n Orange Tabby \n Not adopted \n 11 \n \n \n 3 \n A806701 \n *Emerald \n 2019-11-14 14:41:00 \n 2019-11-14 14:41:00 \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair \n Blue Tabby/White \n Adopted \n 11 \n \n \n 4 \n A804553 \n *Wendy \n 2019-11-14 14:36:00 \n 2019-11-14 14:36:00 \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n Adopted \n 11 \n \n \n \n5 \n A804552 \n *Tinkerbell \n 2019-11-14 14:35:00 \n 2019-11-14 14:35:00 \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n Adopted \n 11 \n \n \n
\n\n \n \n \n \n animal_id \n name \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n month_arrived \n season_arrived \n year_arrived \n \n \n 1 \n A781697 \n Pookie \n Dog \n Spayed Female \n 2 years \n Cairn Terrier \n White/Brown \n Adopted \n 11 \n Fall \n 2019 \n \n \n 2 \n A808382 \n Unknown \n Cat \n Intact Male \n 5 years \n Domestic Shorthair \n Orange Tabby \n Not adopted \n 11 \n Fall \n 2019 \n \n \n 3 \n A806701 \n *Emerald \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair \n Blue Tabby/White \n Adopted \n 11 \n Fall \n 2019 \n \n \n 4 \n A804553 \n *Wendy \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n Adopted \n 11 \n Fall \n 2019 \n \n \n 5 \n A804552 \n *Tinkerbell \n Cat \n Spayed Female \n 3 months \n Domestic Shorthair \n Calico \n Adopted \n 11 \n Fall \n 2019 \n \n \n 6 \n A808132 \n Daryl \n Cat \n Neutered Male \n 5 years \n Domestic Shorthair \n Brown Tabby/White \n Adopted \n 11 \n Fall \n 2019 \n \n \n 7 \n A805655 \n *Fezzik \n Cat \n Neutered Male \n 2 months \n Domestic Shorthair \n Orange Tabby \n Adopted \n 11 \n Fall \n 2019 \n \n \n 9 \n A808526 \n Jugez \n Dog \n Spayed Female \n 13 years \n Shih Tzu \n Brown/Cream \n Not adopted \n 11 \n Fall \n 2019 \n \n \n 10 \n A787448 \n Watermelon \n Dog \n Spayed Female \n 3 years \n Labrador Retriever Mix \n Brown Tiger/White \n Adopted \n 11 \n Fall \n 2019 \n \n \n \n11 \n A808522 \n Unknown \n Cat \n Intact Female \n 4 years \n Domestic Shorthair \n Brown Tabby \n Not adopted \n 11 \n Fall \n 2019 \n \n \n
\n\n \n \n \n \n animal_id \n name \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n month_arrived \n season_arrived \n year_arrived \n \n \n 1 \n A781697 \n Pookie \n Dog \n Spayed Female \n 2 years \n Cairn Terrier \n White/Brown \n Adopted \n 11 \n Fall \n 2019 \n \n \n 9 \n A808526 \n Jugez \n Dog \n Spayed Female \n 13 years \n Shih Tzu \n OTHER \n Not adopted \n 11 \n Fall \n 2019 \n \n \n 10 \n A787448 \n Watermelon \n Dog \n Spayed Female \n 3 years \n Labrador Retriever Mix \n OTHER \n Adopted \n 11 \n Fall \n 2019 \n \n \n 17 \n A808589 \n Lola \n Dog \n Spayed Female \n 5 years \n OTHER \n Brown Brindle \n Not adopted \n 11 \n Fall \n 2019 \n \n \n \n18 \n A808590 \n Cheyenne \n Dog \n Spayed Female \n 7 years \n Australian Shepherd Mix \n Brown/White \n Not adopted \n 11 \n Fall \n 2019 \n \n \n
\n\n \n \n \n \n animal_id \n name \n animal_type \n sex_upon_outcome \n age_upon_outcome \n breed \n color \n new_outcome_type \n month_arrived \n season_arrived \n year_arrived \n \n \n 1 \n A781697 \n Pookie \n Dog \n 2 \n 2.0 \n Cairn Terrier \n White/Brown \n Adopted \n 11 \n Fall \n 2019 \n \n \n 9 \n A808526 \n Jugez \n Dog \n 2 \n 13.0 \n Shih Tzu \n OTHER \n Not adopted \n 11 \n Fall \n 2019 \n \n \n 10 \n A787448 \n Watermelon \n Dog \n 2 \n 3.0 \n Labrador Retriever Mix \n OTHER \n Adopted \n 11 \n Fall \n 2019 \n \n \n 17 \n A808589 \n Lola \n Dog \n 2 \n 5.0 \n OTHER \n Brown Brindle \n Not adopted \n 11 \n Fall \n 2019 \n \n \n \n18 \n A808590 \n Cheyenne \n Dog \n 2 \n 7.0 \n Australian Shepherd Mix \n Brown/White \n Not adopted \n 11 \n Fall \n 2019 \n \n \n
\n\n \n \n \n \n animal_id \n name \n animal_type \n sex_upon_outcome \n breed \n color \n new_outcome_type \n month_arrived \n season_arrived \n year_arrived \n \n \n 1 \n A781697 \n Pookie \n Dog \n 2 \n Cairn Terrier \n White/Brown \n Adopted \n 11 \n Fall \n 2019 \n \n \n 9 \n A808526 \n Jugez \n Dog \n 2 \n Shih Tzu \n OTHER \n Not adopted \n 11 \n Fall \n 2019 \n \n \n 10 \n A787448 \n Watermelon \n Dog \n 2 \n Labrador Retriever Mix \n OTHER \n Adopted \n 11 \n Fall \n 2019 \n \n \n 17 \n A808589 \n Lola \n Dog \n 2 \n OTHER \n Brown Brindle \n Not adopted \n 11 \n Fall \n 2019 \n \n \n \n18 \n A808590 \n Cheyenne \n Dog \n 2 \n Australian Shepherd Mix \n Brown/White \n Not adopted \n 11 \n Fall \n 2019 \n
\n\n\n
\n\nAssign either 'within' or 'between' to the variables corresponding to the studies above (i.e., study_1, study_2, study_3).\n\n
\nSuppose a researcher wants to implement a decoding analysis in which he/she aims to predict schizophrenia (vs. healthy control) from gray-matter density patterns in the orbitofrontal cortex. Is this an example of a within-subject or between-subject pattern analysis? Can it be either one? Why (not)? \n
\n \nCompute the correlation between, for example, the predictors associated with trial 1 and trial 2, using the pearsonr function imported below, and store it in a variable named corr_t1t2 (1 point). Then, try to think of a way to improve the efficiency of this particular LSA design and write it down in the cell below the test cell.\n
PCA to the rescue! Run PCA on the estimated patterns (beta_hat) and store the PCA-transformed array (shape: $20 \\times 2$) in a variable named beta_hat_2d. Then, try to plot the first two components as a scatterplot. Make it even nicer by plotting the trials from condition A as red points and trials from condition B als orange points. \n
\n \n1. Remove all columns except \"onset\", \"duration\", and \"trial_type\". You should end up with a DataFrame with 40 rows and 3 columns. You can check this with the .shape attribute of the DataFrame. (Note that, technically, you could model the reponse and rating-related events as well! For now, we'll exclude them.) Name this filtered DataFrame events_df_filt.\n \n2. You also need to select specific columns from the confounds DataFrame, as we don't want to include all confounds! For now, include only the motion parameters (trans_x, trans_y, trans_z, rot_x, rot_y, rot_z). You should end up with a confounds DataFrame with 342 rows and 6 columns. Name this filtered DataFrame confs_df_filt.\n
\n \n1. Set the correct TR (this is 0.7)\n2. Set the slice time reference to 0.5\n3. Set the mask image to the one we defined before\n4. Use a \"glover\" HRF\n5. Use a \"cosine\" drift model with a cutoff of 0.01 Hz\n6. Do not apply any smoothing\n7. Set minimize_memory to true\n8. Use an \"ols\" noise model\n\nThen, fit your model using the functional data (func), filtered confounds, and filtered events we defined before. \n\n
\n\n\n\n FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…\n\n\n SparkSession available as 'spark'.\n\n\n\n FloatProgress(value=0.0, bar_style='info', description='Progress:', layout=Layout(height='25px', width='50%'),…\n\n\n Missing parentheses in call to 'print'. Did you mean print(sys.version)? (ID YARN Application ID Kind State Spark UI Driver log Current session? 2 application_1571347151292_0003 pyspark idle Link Link ✔ \n
\n\nIn this tutorial, we implement the quantum approximate optimization algorithm (QAOA) for determining the Max-Cut of the Bristlecone processor's hardware graph (with random edge weights). To do so, we will:\n\n1. Define a random set of weights over the hardware graph.\n2. Construct a QAOA circuit using Cirq.\n3. Calculate the expected value of the QAOA cost function.\n4. Create an outer loop optimization to minimize the cost function.\n5. Compare cuts found from QAOA with random cuts.\n\n\n```\ntry:\n import cirq\nexcept ImportError:\n print(\"installing cirq...\")\n !pip install --quiet cirq\n print(\"installed cirq.\")\n```\n\n## 1. Defining a random set of weights over the hardware graph\nIn order to make the problem easily embeddable on a quantum device, we will look at the problem of Max-Cut on the same graph that the device's qubit connectivity defines, but with random valued edge weights.\n\n\n```\nimport cirq\nimport sympy\nimport numpy as np\nimport matplotlib.pyplot as plt\nworking_device = cirq.google.Bristlecone\nprint(working_device)\n```\n\n (0, 5)────(0, 6)\n │ │\n │ │\n (1, 4)───(1, 5)────(1, 6)────(1, 7)\n │ │ │ │\n │ │ │ │\n (2, 3)───(2, 4)───(2, 5)────(2, 6)────(2, 7)───(2, 8)\n │ │ │ │ │ │\n │ │ │ │ │ │\n (3, 2)───(3, 3)───(3, 4)───(3, 5)────(3, 6)────(3, 7)───(3, 8)───(3, 9)\n │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │\n (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)────(4, 6)────(4, 7)───(4, 8)───(4, 9)───(4, 10)\n │ │ │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │ │ │\n (5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)────(5, 6)────(5, 7)───(5, 8)───(5, 9)───(5, 10)───(5, 11)\n │ │ │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │ │ │\n (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)────(6, 6)────(6, 7)───(6, 8)───(6, 9)───(6, 10)\n │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │\n (7, 2)───(7, 3)───(7, 4)───(7, 5)────(7, 6)────(7, 7)───(7, 8)───(7, 9)\n │ │ │ │ │ │\n │ │ │ │ │ │\n (8, 3)───(8, 4)───(8, 5)────(8, 6)────(8, 7)───(8, 8)\n │ │ │ │\n │ │ │ │\n (9, 4)───(9, 5)────(9, 6)────(9, 7)\n │ │\n │ │\n (10, 5)───(10, 6)\n\n\nSince a circuit covering the entire Bristlecone device cannot be easily simulated, a small subset of the device graph will be used instead.\n\n\n```\nimport networkx as nx\n\n# Set the seed to determine the problem instance.\nnp.random.seed(seed=11)\n\n# Identify working qubits from the device.\ndevice_qubits = working_device.qubits\nworking_qubits = sorted(device_qubits)[:12]\n\n# Populate a networkx graph with working_qubits as nodes.\nworking_graph = nx.Graph()\nfor qubit in working_qubits:\n working_graph.add_node(qubit)\n\n# Pair up all neighbors with random weights in working_graph.\nfor qubit in working_qubits:\n for neighbor in working_device.neighbors_of(qubit):\n if neighbor in working_graph:\n # Generate a randomly weighted edge between them. Here the weighting\n # is a random 2 decimal floating point between 0 and 5.\n working_graph.add_edge(\n qubit, neighbor, weight=np.random.randint(0, 500) / 100\n )\n\nnx.draw_circular(working_graph, node_size=1000, with_labels=True)\nplt.show()\n```\n\n## 2. Construct the QAOA circuit\nNow that we have created a Max-Cut problem graph, it's time to generate the QAOA circuit following [Farhi et al.](https://arxiv.org/abs/1411.4028). For simplicity $p = 1$ is chosen.\n\n\n```\nfrom cirq.contrib.svg import SVGCircuit\n\n# Symbols for the rotation angles in the QAOA circuit.\nalpha = sympy.Symbol('alpha')\nbeta = sympy.Symbol('beta')\n\nqaoa_circuit = cirq.Circuit(\n # Prepare uniform superposition on working_qubits == working_graph.nodes\n cirq.H.on_each(working_graph.nodes()),\n\n # Do ZZ operations between neighbors u, v in the graph. Here, u is a qubit,\n # v is its neighboring qubit, and w is the weight between these qubits.\n (cirq.ZZ(u, v) ** (alpha * w['weight']) for (u, v, w) in working_graph.edges(data=True)),\n\n # Apply X operations along all nodes of the graph. Again working_graph's\n # nodes are the working_qubits. Note here we use a moment\n # which will force all of the gates into the same line.\n cirq.Moment(cirq.X(qubit) ** beta for qubit in working_graph.nodes()),\n \n # All relevant things can be computed in the computational basis.\n (cirq.measure(qubit) for qubit in working_graph.nodes()),\n)\nSVGCircuit(qaoa_circuit)\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\n## 3. Calculating the expected value of the QAOA cost Hamiltonian\nNow that we have created a parameterized QAOA circuit, we need a way to calculate expectation values of the cost Hamiltonian. For Max-Cut, the cost Hamiltonian is\n\n$$\n H_C = \\frac{1}{2} \\sum_{\\langle i, j\\rangle} w_{ij} (1 - Z_i Z_j )\n$$\n\nwhere $\\langle i, j \\rangle$ denotes neighboring qubits, $w_{ij}$ is the weight of edge $ij$, and $Z$ is the usual Pauli-$Z$ matrix. The expectation value of this cost Hamiltonian is $\\langle \\alpha, \\beta | H_C | \\alpha, \\beta \\rangle$ where $|\\alpha, \\beta\\rangle$ is the quantum state prepared by our `qaoa_circuit`. This is the cost function we need to estimate.\n\n> Pauli-$Z$ has eigenvalues $\\pm 1$. If qubits $i$ and $j$ are in the same eigenspace, then $\\langle Z_i Z_j \\rangle = 1$ and so $\\frac{1}{2} w_{ij} \\langle 1 - Z_i Z_j \\rangle = 0$. In the Max-Cut language, this means that edge $ij$ does not contribute to the cost. If qubits $i$ and $j$ are in the opposite eigenspace, then $\\langle Z_i Z_j \\rangle = -1$ and so $\\frac{1}{2} w_{ij} \\langle 1 - Z_i Z_j \\rangle = w_{ij}$. In the Max-Cut language, this means that edge $ij$ contributes its weight $w_{ij}$ to the cost. \n\nTo estimate the cost function, we need to estimate the (weighted) sum of all $ZZ$ pairs in the graph. Since these terms are diagonal in the same basis (namely, the computational basis), they can measured simultaneously. Given a set of measurements (samples), the function below estimates the cost function.\n\n> *Note*: We say \"estimate the cost\" instead of \"compute the cost\" since we are sampling from the circuit. This is how the cost would be evaluated when running QAOA on a real quantum processor.\n\n\n```\ndef estimate_cost(graph, samples):\n \"\"\"Estimate the cost function of the QAOA on the given graph using the\n provided computational basis bitstrings.\"\"\"\n cost_value = 0.0\n\n # Loop over edge pairs and compute contribution.\n for u, v, w in graph.edges(data=True):\n u_samples = samples[str(u)]\n v_samples = samples[str(v)]\n\n # Determine if it was a +1 or -1 eigenvalue.\n u_signs = (-1)**u_samples\n v_signs = (-1)**v_samples\n term_signs = u_signs * v_signs\n\n # Add scaled term to total cost.\n term_val = np.mean(term_signs) * w['weight']\n cost_value += term_val\n\n return -cost_value\n```\n\nNow we can sample from the `qaoa_circuit` and use `estimate_expectation` to calculate the expectation value of the cost function for the circuit. Below, we use arbitrary values for $\\alpha$ and $\\beta$.\n\n\n```\nalpha_value = np.pi / 4\nbeta_value = np.pi / 2\nsim = cirq.Simulator()\n\nsample_results = sim.sample(\n qaoa_circuit, \n params={alpha: alpha_value, beta: beta_value}, \n repetitions=20_000\n)\nprint(f'Alpha = {round(alpha_value, 3)} Beta = {round(beta_value, 3)}')\nprint(f'Estimated cost: {estimate_cost(working_graph, sample_results)}')\n```\n\n Alpha = 0.785 Beta = 1.571\n Estimated cost: -0.22279300000000013\n\n\n## 4. Outer loop optimization\nNow that we can compute the cost function, we want to find the optimal cost. There are lots of different techniques to choose optimal parameters for the `qaoa_circuit`. Since there are only two parameters here ($\\alpha$ and $\\beta$), we can keep things simple and sweep over incremental pairings using `np.linspace` and track the minimum value found along the way.\n\n\n```\n# Set the grid size = number of points in the interval [0, 2π).\ngrid_size = 5\n\nexp_values = np.empty((grid_size, grid_size))\npar_values = np.empty((grid_size, grid_size, 2))\n\nfor i, alpha_value in enumerate(np.linspace(0, 2 * np.pi, grid_size)):\n for j, beta_value in enumerate(np.linspace(0, 2 * np.pi, grid_size)):\n samples = sim.sample(\n qaoa_circuit,\n params={alpha: alpha_value, beta: beta_value},\n repetitions=20000\n )\n exp_values[i][j] = estimate_cost(working_graph, samples)\n par_values[i][j] = alpha_value, beta_value\n```\n\nWe can now visualize the cost as a function of $\\alpha$ and $\\beta$.\n\n\n```\nplt.title('Heatmap of QAOA Cost Function Value')\nplt.xlabel(r'$\\alpha$')\nplt.ylabel(r'$\\beta$')\nplt.imshow(exp_values);\n```\n\nThis heatmap is coarse because we selected a small `grid_size`. To see more detail in the heatmap, one can increase the `grid_size`. \n\n## 5. Compare cuts\n\nWe now compare the optimal cut found by QAOA to a randomly selected cut. The helper function draws the `working_graph` and colors nodes in different sets different colors. Additionally, we print out the cost function for the given cut.\n\n\n```\ndef output_cut(S_partition):\n \"\"\"Plot and output the graph cut information.\"\"\"\n\n # Generate the colors.\n coloring = []\n for node in working_graph:\n if node in S_partition:\n coloring.append('blue')\n else:\n coloring.append('red')\n\n # Get the weights\n edges = working_graph.edges(data=True)\n weights = [w['weight'] for (u,v, w) in edges]\n\n nx.draw_circular(\n working_graph,\n node_color=coloring,\n node_size=1000,\n with_labels=True,\n width=weights)\n plt.show()\n size = nx.cut_size(working_graph, S_partition, weight='weight')\n print(f'Cut size: {size}')\n```\n\nAs an example, we can test this function with all nodes in the same set, for which the cut size should be zero.\n\n\n```\n# Test with the empty S and all nodes placed in T.\noutput_cut([])\n```\n\nTo get cuts using the QAOA we will first need to extract the best control parameters found during the sweep:\n\n\n```\nbest_exp_index = np.unravel_index(np.argmax(exp_values), exp_values.shape)\nbest_parameters = par_values[best_exp_index]\nprint(f'Best control parameters: {best_parameters}')\n```\n\n Best control parameters: [3.14159265 6.28318531]\n\n\nEach bitstring can be seen as a candidate cut in the graph. The qubits that measured 0 correspond to that qubit being in one cut partition and a qubit that measured to 1 corresponds to that qubit being in the other cut partition. Now that we've found good parameters for the `qaoa_circuit`, we can just sample some bistrings, iterate over them and pick the one that gives the best cut:\n\n\n```\n# Number of candidate cuts to sample.\nnum_cuts = 100\ncandidate_cuts = sim.sample(\n qaoa_circuit,\n params={alpha: best_parameters[0], beta: best_parameters[1]},\n repetitions=num_cuts\n)\n\n# Variables to store best cut partitions and cut size.\nbest_qaoa_S_partition = set()\nbest_qaoa_T_partition = set()\nbest_qaoa_cut_size = -np.inf\n\n# Analyze each candidate cut.\nfor i in range(num_cuts):\n candidate = candidate_cuts.iloc[i]\n one_qubits = set(candidate[candidate==1].index)\n S_partition = set()\n T_partition = set()\n for node in working_graph:\n if str(node) in one_qubits:\n # If a one was measured add node to S partition.\n S_partition.add(node)\n else:\n # Otherwise a zero was measured so add to T partition.\n T_partition.add(node)\n\n cut_size = nx.cut_size(\n working_graph, S_partition, T_partition, weight='weight')\n \n # If you found a better cut update best_qaoa_cut variables.\n if cut_size > best_qaoa_cut_size:\n best_qaoa_cut_size = cut_size\n best_qaoa_S_partition = S_partition\n best_qaoa_T_partition = T_partition\n```\n\nThe QAOA is known to do just a little better better than random guessing for Max-Cut on 3-regular graphs at `p=1`. You can use very similar logic to the code above, but now instead of relying on the QAOA to decied your `S_partition` and `T_partition` you can just pick then randomly:\n\n\n```\nimport random\n\nbest_random_S_partition = set()\nbest_random_T_partition = set()\nbest_random_cut_size = -9999\n\n# Randomly build candidate sets.\nfor i in range(num_cuts):\n S_partition = set()\n T_partition = set()\n for node in working_graph:\n if random.random() > 0.5:\n # If we flip heads add to S.\n S_partition.add(node)\n else:\n # Otherwise add to T.\n T_partition.add(node)\n\n cut_size = nx.cut_size(\n working_graph, S_partition, T_partition, weight='weight')\n \n # If you found a better cut update best_random_cut variables.\n if cut_size > best_random_cut_size:\n best_random_cut_size = cut_size\n best_random_S_partition = S_partition\n best_random_T_partition = T_partition\n```\n\n\n```\nprint('-----QAOA-----')\noutput_cut(best_qaoa_S_partition)\n\nprint('\\n\\n-----RANDOM-----')\noutput_cut(best_random_S_partition)\n```\n\nFor this problem instance, one should see that $p = 1$ QAOA performs better, on average, than randomly guessing.\n", "meta": {"hexsha": "c1c2673b740b77e964dfab491d6f6d592ef35b2b", "size": 225388, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/qaoa.ipynb", "max_stars_repo_name": "alex-treebeard/Cirq", "max_stars_repo_head_hexsha": "10594c0edf7a4c26d5d21f985c6dc391197d3075", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2021-01-05T19:47:55.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T19:47:55.000Z", "max_issues_repo_path": "docs/tutorials/qaoa.ipynb", "max_issues_repo_name": "rohitvuppala/Cirq", "max_issues_repo_head_hexsha": "0ff2894e053e4ce3bb1b54e9b9de1cc4345d10b3", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2021-01-11T10:35:37.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-28T19:17:02.000Z", "max_forks_repo_path": "docs/tutorials/qaoa.ipynb", "max_forks_repo_name": "rohitvuppala/Cirq", "max_forks_repo_head_hexsha": "0ff2894e053e4ce3bb1b54e9b9de1cc4345d10b3", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-12-30T21:50:00.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-30T21:50:00.000Z", "avg_line_length": 301.320855615, "max_line_length": 42228, "alphanum_fraction": 0.8792482297, "converted": true, "num_tokens": 4191, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.42632160712508727, "lm_q2_score": 0.1755380649971796, "lm_q1q2_score": 0.07483566998122564}}
{"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# Tarea 8\n\n## Transformada de Laplace de una integral de convolución\n\nQueremos obtener:\n\n$$\n\\mathcal{L} \\left\\{ \\int_{-\\tau}^0 G(\\theta) x(\\tau + \\theta) d\\theta \\right\\}\n$$\n\nPodemos definir la integral de convolución para dos funciones continuas $f(t)$ y $g(t)$, tales que la convolución $(f*g)(t)$ es de la forma:\n\n$$\n(f*g)(t) = \\int_0^t f(t - \\tau) g(\\tau) d\\tau\n$$\n\ny la transformada de Laplace de esta integral de convolución es:\n\n$$\n\\mathcal{L} \\left\\{ (f*g)(t) \\right\\} = F(s)G(s)\n$$\n\npor lo que nos interesa poner nuestra integral original de manera que sea una integral de convolución.\n\nPodemos ver que al aplicar el cambio de variable $\\delta = \\theta + \\tau$, cuando $\\theta$ variaba de $-\\tau \\to 0$, $\\delta$ variará de $0 \\to \\tau$ y el diferencial $d\\theta$ es equivalente a $d\\delta$, por lo que nuestra integral quedará:\n\n$$\n\\mathcal{L} \\left\\{ \\int_{0}^{\\tau} G(\\delta - \\tau) x(\\tau + \\delta - \\tau) d\\delta \\right\\} = \\mathcal{L} \\left\\{ \\int_{0}^{\\tau} G(\\delta - \\tau) x(\\delta) d\\delta \\right\\}\n$$\n\ny etsa integral ya es de la forma de la integral de convolución, por lo que podemos escribirla como:\n\n$$\n\\mathcal{L} \\left\\{ (G*x)(t) \\right\\} = G(s) x(s)\n$$\n\n## Diseño de un controlador predictivo para un sistema con retardo en la entrada\n\nDado el sistema con retardo en la entrada:\n\n$$\n\\dot{x}(t) = A x(t) + B u(t - h)\n$$\n\n$$\ny(t) = C x(t)\n$$\n\nEmpezaremos creando un modelo sin retardo para el diseño del controlador predictor de Smith. Si logramos diseñar un controlador $C(s)$ que estabilice de manera aceptable al sistema sin retardos, podremos diseñar otro $\\tilde{C}(s)$ que tenga el mismo comportamiento agregado el efecto del retardo.\n\n\n\nen donde $\\tilde{C}(s)$ será de la forma:\n\n\n\nes decir:\n\n$$\n\\tilde{C}(s) = \\frac{C(s)}{1 + C(s) \\hat{G}(s) \\left( 1 - e^{-sh} \\right)}\n$$\n\nen donde $\\hat{G}(s)$ es la parte de la función de transferencia del sistema que no incluye al retardo. Por lo que nuestra primera tarea es encontrar la función de transferencia para nuestro sistema sin el efecto del retardo.\n\nConsideremos pues el sistema\n\n$$\n\\dot{x}(t) = A x(t) + B u(t)\n$$\n\n$$\ny(t) = C x(t)\n$$\n\npara el cual la función de transferencia se puede obtener por la siguiente ecuación:\n\n$$\n\\hat{G}(s) = C \\left( sI - A \\right)^{-1} B\n$$\n\ncabe mencionar que la función de transferencia para el sistema con retardo es:\n\n$$\nG(s) = C \\left( sI - A \\right)^{-1} B e^{-sh}\n$$\n\npor lo que en efecto $\\hat{G}(s)$ es la parte de la función de transferencia del sistema sin el efecto del retardo:\n\n$$\nG(s) = \\hat{G}(s) e^{-sh}\n$$\n\n\n```python\n# Se importan las librerias para calculo simbolico\nfrom IPython.display import display\n\nfrom sympy import var, simplify, collect, expand, solve, sin, cos, Matrix, eye, diff, Function, expand_power_base\nfrom sympy.physics.mechanics import mlatex, mechanics_printing\nmechanics_printing()\n```\n\n\n```python\n%matplotlib inline\nfrom matplotlib.pyplot import plot, style, figure, legend\nstyle.use(\"ggplot\")\n```\n\n\n```python\nfrom control import tf, step, pade, acker, ss, feedback\nfrom numpy import linspace, matrix, eye\n```\n\n\n```python\nvar(\"s\")\n```\n\nEmpezaremos con el sistema $A_1 = \\begin{pmatrix} 0 & 1 \\\\ 0 & 0 \\end{pmatrix}$, $B_1 = \\begin{pmatrix} 0 \\\\ 1 \\end{pmatrix}$, $C_1 = \\begin{pmatrix} 1 & 0 \\end{pmatrix}$ y $h = 1$.\n\n\n```python\nA1 = Matrix([[0, 1], [0, 0]])\nB1 = Matrix([[0], [1]])\nC1 = Matrix([[1, 0]])\n\nG1 = (C1*(s*eye(2) - A1).inv()*B1)[0]\nG1\n```\n\n\n```python\nt = linspace(0, 10, 100)\nt.max()\n```\n\nPodemos notar que la función de transferencia de este sistema es:\n\n$$\nG(s) = \\frac{1}{s^2}\n$$\n\n\n```python\n# Convertimos las matrices simbolicas en matrices de tipo numerico\nA1 = matrix(A1.tolist(), dtype=float)\nB1 = matrix(B1.tolist(), dtype=float)\nC1 = matrix(C1.tolist(), dtype=float)\n```\n\nPara obtener dos polos en $-1$ podemos usar la función ```acker()``` para obtener las ganancias de nuestro controlador PD, el cual utilizaremos para estabilizar nuestro sistema.\n\n\n```python\nk1 = acker(A1, B1, (-1, -1))\nk1\n```\n\n\n\n\n matrix([[ 1., 2.]])\n\n\n\nDefinimos una función que calculará todos los controladores que deseamos, segun la ecuación que ya dimos:\n\n$$\n\\tilde{C}(s) = \\frac{C(s)}{1 + C(s) \\hat{G}(s) \\left( 1 - e^{-sh} \\right)}\n$$\n\nAl final gráfica la respuesta del sistema con y sin efecto del retardo, asi como con y sin controlador.\n\n\n```python\ndef smith_predictor(A, B, C, D, k, tau=1, t=(0, 10)):\n '''Predictor de Smith\n \n Esta función toma los arreglos A, B, C, D de un sistema con retardo en la entrada\n y crea un controlador PD con los valores de k = [kp, kd] que estabiliza al sistema\n sin retardos. Ademas crea un controlador que estabiliza al sistema con retardo,\n dada la condición de que este sistema sea estable, y grafica la salida de los\n con y sin realimentación y con y sin retardo tau del tiempo t0 al tiempo t1\n especificados en t = (t0, t1).\n \n Ejemplo\n -------\n >>> A1 = [[0, 1], [0, 0]]\n >>> B1 = [[0], [1]]\n >>> C1 = [[1, 0]]\n >>> D1 = 0\n >>> tau1 = 1\n >>> t = (0, 10)\n >>> smith_predictor(A1, B1, C1, D1, [1, 2], tau, t)\n '''\n from control import ss, tf, pade, step, feedback\n from numpy import linspace\n from matplotlib.pyplot import figure, plot, legend\n \n kp, kd = k\n ts = linspace(t[0], t[1], 1000)\n \n sis = ss(A, B, C, D)\n cont = tf([kd, kp], [0, 1])\n \n num, den = pade(T=tau, n=10)\n delay = tf(num, den)\n \n delcont = ((1 - delay)*sis)\n \n y, t1 = step(sis, ts)\n yd, td = step(sis*delay, ts)\n ycont, tcont = step((cont*sis).feedback(), ts)\n ycontdel, tcontdel = step(feedback(feedback(cont, delcont)*sis), ts)\n \n f = figure(figsize=(10, 6))\n\n p1, = plot(td, yd)\n p2, = plot(t1, y)\n p3, = plot(tcont, ycont)\n p4, = plot(tcontdel, ycontdel)\n\n ax = f.gca()\n ax.set_xlim(t[0] - 0.1, t[1])\n ax.set_ylim(-0.10*ycont.max(), 1.1*ycont.max())\n\n ax.set_ylabel(r\"$y(t)$\", fontsize=20)\n ax.set_xlabel(r\"$t$\", fontsize=20)\n\n legend([p1, p2, p3, p4],\n [r\"$G(s)$\",\n r\"$\\hat{G}(s)$\",\n r\"$\\hat{G}_F(s)$\",\n r\"$G_F(s)$\"], loc=4, fontsize=16);\n```\n\nPor lo que si le damos nuestro sistema con las ganancias deseadas, asi como el tiempo para el que nos interesa, y el retardo, tendremos:\n\n\n```python\nsmith_predictor(A1, B1, C1, 0, k=[3, 3], t=(0, 7), tau=1)\n```\n\nAhora definimos el sistema $A_2 = \\begin{pmatrix} 0 & 1 \\\\ -1 & 0 \\end{pmatrix}$, $B_2 = \\begin{pmatrix} 0 \\\\ 1 \\end{pmatrix}$, $C_2 = \\begin{pmatrix} 1 & 0 \\end{pmatrix}$ y $h = 1$.\n\n\n```python\nA2 = Matrix([[0, 1], [-1, 0]])\nB2 = Matrix([[0], [1]])\nC2 = Matrix([[1, 0]])\n\nG2 = (C2*(s*eye(2) - A2).inv()*B2)[0]\nG2\n```\n\nPor lo que la función de transferencia de este sistema es:\n\n$$\nG(s) = \\frac{1}{s^2 + 1}\n$$\n\n\n```python\n# Convertimos las matrices simbolicas en matrices de tipo numerico\nA2 = matrix(A2.tolist(), dtype=float)\nB2 = matrix(B2.tolist(), dtype=float)\nC2 = matrix(C2.tolist(), dtype=float)\n```\n\nPara obtener dos polos en $-1$ podemos usar la función ```acker()``` para obtener las ganancias de nuestro controlador PD.\n\n\n```python\nk2 = acker(A2, B2, (-1, -1))\nk2\n```\n\n\n\n\n matrix([[ 0., 2.]])\n\n\n\nY la respuesta del sistema es:\n\n\n```python\nsmith_predictor(A2, B2, C2, 0, k=[3, 3], t=(0, 8))\n```\n\nPuedes acceder a este notebook a traves de la página\n\nhttp://bit.ly/1wiwlpl\n\no escaneando el siguiente código:\n\n\n\n\n```python\n# Codigo para generar codigo :)\nfrom qrcode import make\nimg = make(\"http://bit.ly/1wiwlpl\")\nimg.save(\"codigos/codigo8.jpg\")\n```\n", "meta": {"hexsha": "23939d712247a5b95139ee38d3f22af1316b8ba7", "size": 108519, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "IPythonNotebooks/Sistemas con retardo en la entrada/Tarea 8.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/Sistemas con retardo en la entrada/Tarea 8.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/Sistemas con retardo en la entrada/Tarea 8.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": 149.6813793103, "max_line_length": 48136, "alphanum_fraction": 0.8693316378, "converted": true, "num_tokens": 3292, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.25683199138751883, "lm_q2_score": 0.29098086006635987, "lm_q1q2_score": 0.07473319374649616}}
{"text": "\n View on QuantumAI\n \n \n Run in Google Colab\n \n \n View source on GitHub\n \n \n Download notebook\n \nDinámica
\nCapítulo 3: Cinemática y Cinética de partículas
\nMovimiento parabólico
\n2021/02
\nMEDELLÍN - COLOMBIA
\n\n\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/Dinamica\n\n***Herramienta:*** [Jupyter](http://jupyter.org/)\n\n***Kernel:*** Python 3.9\n\n\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 \nTabla de Contenidos
\n \n
\n\n***Solución analítica:***\n\n- ***Sistema de coordenadas*** Se establece el origen en el punto $A$, donde comienza la trayectoria de la partícula (saco). Se observa que la velocidad inicial del saco presenta dos componentes, donde $v_{Ax}=12m/s$ y $v_{Ay}=0$. La acelaración en todo el recorrido, entre $A$ y $B$, es de $a_y=-9.81 m/s^2$. También se observa que se cumple que $v_{Bx}=v_{Ax}=12m/s$ (por qué?). Con lo anterior, las tres incógnitas restantes son $v_{By}$, $R$, y el tiempo de vuelo $t_{AB}$.\n\n\n- ***Movimiento vertical $\\left(+\\uparrow \\right)$:*** Del enunciado, se conoce la distancia vertical $A-B$, que será $y_B=6m$\n\n$$y_B=y_A+v_{Ay}t_{AB}+\\frac{1}{2}a_ct_{AB}^2$$\n\nreemplazando valores se tiene\n\n$$0=6m+0 \\times t_{AB}+\\frac{1}{2}(-9.81m/s^2)t_{AB}^2$$\n\n$$t_{AB}=1.11 s$$\n\nUna vez calculado el tiempo, la distancia horizontal, $R$ se determina así:\n\n\n- ***Movimiento horizontal $\\left(\\underrightarrow{+}\\right)$:***\n\n$$x_B=x_A+v_{Ax}t_{AB}$$\n$$R=0+12m/s(1.11s)$$\n$$R=13.3m$$\n\n\n***Solución computacional:***\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import *\nimport seaborn as sns\n\nt,R = symbols('t R')\ninit_printing(use_latex='mathjax')\n```\n\n\n```python\n# condiciones iniciales\nx0 = 0 # coordenada xA\ny0 = 6 # coordenada yA\nv0x = 12 # Veloc en A en la dirección x\nv0y = 0 # Veloc en A en la dirección y\ny = 0 # Altura final \nac = -9.81 # aceleración debida a la gravedad\n```\n\n\n```python\n# Ecuación del movimiento vertical\nyd2 = Eq(y, y0 + v0y * t + ac * t**2 / 2)\nyd2\n```\n\n\n```python\n# Resolviendo para t\ntiempo = solve(yd2,t)\nprint(\"El tiempo de caída de cada saco es de {0:6.4f} s\".format(tiempo[1]))\n```\n\n\n```python\ntiempo\n```\n\n\n```python\nxd2 = Eq(R, x0 + v0x * tiempo[0])\nxd2\n```\n\n\n```python\n# Ecuación del movimiento horizontal\nR = float(x0 + v0x * tiempo[0])\nprint(\"La distancia a la que caerá cada saco es de {0:6.4f} m\".format(R))\n```\n\n\n```python\n# Graficando\nt = np.linspace(0,np.around(float(tiempo[1]), decimals = 4),100)\n\nx = x0 + v0x * t\ny = y0 + v0y * t + ac * t**2 / 2\n\nplt.plot(x,y);\nplt.xlabel(\"x(m)\")\nplt.ylabel(\"y(m)\")\nplt.grid(True)\n```\n\n## Movimiento curvilíneo: Componentes normal y tangencial\n\n### Introducción\n\n \n \n \n \n\n \n \n
\n\n- ***Sistema de coordenadas:***\n\nSe establece el origen de los ejes $n-t$ en el punto fijo $A$ de la trayectoria.\n\n\n- ***Velocidad:***\n\nComo se definió, la velocidad será siempre tangente a la trayectoria. Como $y = \\frac{1}{20}x^2$, su derivada es $\\frac{dy}{dx}=\\frac{1}{10}x$, reemplazando cuando $x=10m$, $\\frac{dy}{dx}=1$. Por lo tanto, en $A$, $\\boldsymbol{v}$ forma un ángulo $\\theta=\\tan^{-1}(1)=45^{\\circ}$ con el eje $x$. Con esto, la velocidad en $A$ es \n\n$$v_A=6m/s \\quad 45^{\\circ}\\measuredangle$$\n\n\n- ***Aceleración:***\n\nReemplazando las [Ecs. 3.7 y 3.8](#Ec3_7) en la [Ec. 3.6](#Ec3_6) para determinar la aceleración, se llega a:\n\n$$\\boldsymbol{a}=\\dot{v}\\boldsymbol{u}_t+\\frac{v^2}{\\rho}\\boldsymbol{u}_n$$\n\nDe esta ecuación se desconoce el radio de curvatura $\\rho$ de la trayectoria en el punto $A(10,5)$. Empleando la [Ec. 3.10](#Ec3.10) y reemplazando el valor de la coordenada:\n\n$$\\rho=\\frac{\\left[1 + (dy/dx)^2\\right]^{3/2}}{|d^2y/dx^2|}=\\left. \\frac{\\left[1 + (x/10)^2\\right]^{3/2}}{|1/10|} \\right|_{x=10m}=28.28m$$\n\n\nCon lo anterior, la dirección de la aceleración está dada por\n\n$$\n\\begin{align*}\n\\boldsymbol{a} & = \\dot{v} \\boldsymbol{u}_t + \\frac{v^2}{\\rho} \\boldsymbol{u}_n \\\\\n & = 2 \\boldsymbol{u}_t + \\frac{(6m/s)^2}{28.28m} \\boldsymbol{u}_n \\\\\n & = (2 \\boldsymbol{u}_t + 1.273 \\boldsymbol{u}_n) m/s^2\n\\end{align*}\n$$\n\ny cada una de las componentes se representan en la siguiente figura.\n\n\n \n \n \n \n\n \n\n
\n \n
\n\n- ***Sistema de coordenadas:***\nEsta trayectoria es muy rara, y matemáticamente se expresa mejor por medio de coordenadas polares, como se hace aquí, en lugar de coordenadas rectangulares. También, como $\\dot{theta}$ y $\\ddot{\\theta}$ deben determinarse, entonces las coordenadas $r$, $\\theta$ no son una opción obvia.\n\n- ***Velocidad y aceleración:***\n\nEmpleando la regla de la cadena para determinar las derivadas de $r$ y $\\theta$:\n\n\\begin{equation*}\n\\begin{split}\nr&=0.5(1-\\cos\\theta) \\\\\n\\dot{r}&=0.5(\\sin\\theta)\\dot{\\theta}\\\\\n\\ddot{r}&=0.5(\\cos\\theta)\\dot{\\theta}(\\dot{\\theta})+0.5(\\sin\\theta)\\ddot{\\theta}\n\\end{split}\n\\end{equation*}\n\nevaluando cuando $\\theta=180^{\\circ}$, se tiene\n\n$$r=1 pie \\quad\\quad \\dot{r}=0\\quad\\quad\\ddot{r}=-0.5\\dot{\\theta}^2$$\n\ncomo $v=4 pie/s$, utilizando la ecuación [(3.16)](#Ec3_16) para determinar $\\dot{\\theta}$ se tiene\n\n\\begin{equation*}\n\\begin{split}\nv&=\\sqrt{(\\dot{r})^2+(r\\dot{\\theta})^2} \\\\\n4&=\\sqrt{(0)^2+(1\\dot{\\theta})^2}\\\\\n\\dot{\\theta}&=4rad/s \n\\end{split}\n\\end{equation*}\n\nAhora calculando $\\ddot{\\theta}$, empleando la ecuacion [3.21](#Ec3_21)\n\n\\begin{equation*}\n\\begin{split}\na&=\\sqrt{(\\ddot{r}-r\\dot{\\theta}^2)^2+(r\\ddot{\\theta}+2\\dot{r}\\dot{\\theta})^2} \\\\\n30&=\\sqrt{[-0.5(4)^2-1(4)^2]^2+[1\\ddot{\\theta}+2(0)(4)]^2}\\\\\n(30)^2&=(-24)^2+\\ddot{\\theta}^2 \\\\\n\\ddot{\\theta}&=18rad/s^2\n\\end{split}\n\\end{equation*}\n\n- ***Solución computacional:***\n\n\n```python\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sympy import *\nfrom sympy.physics.mechanics import dynamicsymbols, init_vprinting\n\ntheta = dynamicsymbols(r'\\theta')\nt = Symbol('t')\n\ninit_vprinting()\n```\n\nGraficando primero la funcion cardioide\n\n\n```python\nphi = np.linspace(0, 2*np.pi, 1000)\n\nr = 0.5 * (1 - np.cos(phi))\nplt.polar(phi, r, 'r')\nplt.show()\n\n```\n\nAhora obtenemos los valores de $\\dot{r}$ y $\\ddot{r}$\n\n\n```python\nr = 0.5 * (1 - cos(theta))\nrdot = diff(r, t)\nrdot\n```\n\n\n```python\nrddot = diff(rdot, t)\nrddot\n```\n\nEvaluando los anteriores resultados cuando $\\theta=180^{\\circ}$\n\n\n```python\nrN = r.subs(theta, 180 * pi / 180)\nrN\n```\n\n\n```python\nrdotN = rdot.subs(theta, 180 * pi / 180)\nrdotN\n```\n\n\n```python\nrddotN = rddot.subs(theta, 180 * pi / 180)\nrddotN\n```\n\nAhora vamos a determinar el valor numérico para $\\dot{\\theta}$, cuando $v=4pie/s$\n\n\n```python\nthetadot = N(Eq(4, sqrt(rdotN**2 + (rN * theta)**2)))\nthetadot\n```\n\n\n```python\nthetadot = solve(thetadot,theta)\nthetadot\n```\n", "meta": {"hexsha": "c08b12771e76e6239d49dfb71ef825bb6d135975", "size": 55957, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "C03_CinematicaCineticaParticulas_MovParabolico.ipynb", "max_stars_repo_name": "carlosalvarezh/Dinamica", "max_stars_repo_head_hexsha": "c6696cd3292416b5d91e52af3e7928686b707847", "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": "C03_CinematicaCineticaParticulas_MovParabolico.ipynb", "max_issues_repo_name": "carlosalvarezh/Dinamica", "max_issues_repo_head_hexsha": "c6696cd3292416b5d91e52af3e7928686b707847", "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": "C03_CinematicaCineticaParticulas_MovParabolico.ipynb", "max_forks_repo_name": "carlosalvarezh/Dinamica", "max_forks_repo_head_hexsha": "c6696cd3292416b5d91e52af3e7928686b707847", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2021-09-28T18:47:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-09-28T18:47:37.000Z", "avg_line_length": 38.9401530967, "max_line_length": 4297, "alphanum_fraction": 0.586986436, "converted": true, "num_tokens": 12380, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.44552953503957266, "lm_q2_score": 0.16667540054859167, "lm_q1q2_score": 0.07425881370894859}}
{"text": "# Focal Loss for Dense Object Detection\n\n\nFollow [Andrew Ng's](https://www.youtube.com/watch?v=733m6qBH-jI&list=PLoROMvodv4rOABXSygHTsbvUz4G_YQhOb&index=9&t=0s) suggested strategy of multiple passes over a paper. Namely:\n\n\n1. Title, Abstract and Figures\n2. Intro/Conclusion and Skim the rest (Skipping related work)\n3. Read All Remaining Sections (however Skip the maths)\n4. Read Everything (but skip the parts that don't make sense)\n\nAfter some background reading (medium posts, blog posts, other papers, youtube videos from [cs231 2016](https://www.youtube.com/watch?v=GxZrEKZfW2o&t=3s) [cs231 2017](https://www.youtube.com/watch?v=nDPWywWRIRo&t=3909s)), I have made notes below following each pass.\n\n## Title, Abstract and Figures\n\n### Title\nFocal Loss for Dense Object Detection\nComments: \n\nWhat is `Focal Loss`? A new type of loss function called focal loss is introduced in this paper.\n\nWhat is `Dense Object Detection`? Dense object detection is looking for objects in the same image over many densely covered spatial positions, scales and aspect ratios - it is one stage detection approach. \n\n### Abstract\n\n**Comments**\n\nObject detection is a task of finding bounding boxes for zero of more instances of predefined classes on an image. The bounding box is a rectangle that locates and bounds the instance of a class. A solution which does this is called an object detector.\n\nHere is an example:\n\n\n\nThere are two classes of object detection algorithm that are state of the art on competing metrics - namely:\n\n1. Dense object detection performs at the state of the art level of performance, as measured by an accuracy metric: average precision (area under precision recall curve - for different classification thresholds).\n\n\n\n2. Sparse object detection performs at the state of the art level of performance, as measured by speed of prediction on test cases, for a respectable level but not excellent of performance of accuracy on the average precision metric.\n\n\n\n```\nAside: The dense object detection approach is for one stage learning models - those that do proposal, classification, and localization in one shot - such as OverFeat, SSD or YOLO - many (dense) blind possibly overlapping candidate boxes are made and fitted over a grid.\n\nThe sparse object detection approach is a two step approach - where first regions that may contain an object are proposed and then these boxes are put through a classifier - some examples being R-CNN, Fast R-CNN, Faster R-CNN and Mask R-CNN.\n```\n\nThe first approach produces excellent results. However, the second approach provides a \n\n> In contrast, one-stage detectors that are applied\nover a regular, dense sampling of possible object locations\nhave the potential to be faster and simpler, but have trailed\nthe accuracy of two-stage detectors thus far.\n\n`Question: Simpler in what sense? Still very difficult to interpret or understand a sparse object detection model.`\n\nThe authors suggest that the paper identifies the reason for poor performance on sparse object detection. They claim that they are able to pinpoint the blame on *extremely unbalanced data* (no objects >> objects) occurring at training time. That is to say, dense detectors suffer from many more examples of no objects in boxes over an image than examples of boxes with images.\n\nThey have a way to address this imbalance. They notice that no object *boxes* are assigned much lower cost $-log(Pr($no object | box$))$ than $-log(Pr($class j | box$))$ - the probability of class (object) $j$ the classes of objects when they occur in boxes.\n\nEffectively, they are noticing an artifact that the probabilities of no object are more peaked than they should be and the probabilities of the object classes are flatter than they should be. \n\n`Idea: Could what the authors do be translated into applying a regularization or prior to make the optimizer prefer models with flatter no-object probability and more peaky object probabilities. Could we explicitly set the Bayesian prior to achieve the same result`\n\nThe authors view their algorithm as having a *focal loss* which focuses (by having a higher cost) on harder examples (examples with objects present - those with lower probabilities) and having less focus on easy negatives (examples with no object and higher probability - the no object class). They believe this alleviates the problem of the detector being overwhelmed by the imbalanced data, so that learning can still take place. \n\nTo see how well their loss does for dense objects detectors, the authors present a network they dub RetinaNet. Their results show that with the *focal loss* RetinaNet is as fast as the popular one stage detectors, and yet have accuracy (as measures by average precision) as good as the state of the art two stage detectors.\n\n### Figures\n\n#### Figure 1\n\nA graph showing how the proposed novel loss function - focal loss - has the desired properties of increasing cost for low probability values and reducing cost for high probability values. A hyperparameter $\\gamma$ is shown over a range of values. \n\nNote that the proposed loss function is pinned at the extremes of 0 loss for predicting with probability 1 the ground truth and shoots off to infinity asymptote as the probability of predicting the ground truth goes to 0.\n\n#### Figure 2\n\nThis is a plot of Speed vs accuracy (Average Precision) for RetinaNet with base feature extractor network as ResNet100 or ResNet50 compared to other popular competitive algorithms. It shows that RetinaNet is forms an upper enveloper over the other methods and so is superior in speed and accuracy vs the popular algorithms - with one exception. YOLOv2 is faster, but at a much lower accuracy than RetinaNet. \n\n#### Figure 3\nOutline of RetinaNet. The backbone of the network is a Feature Pyramid Network (FPN) - which allows the network to work at various scales. FPN receives inputs from a ConvNet Feature Extractor, and it is connected to two heads: a classifier for the anchor boxes, a regressor to fine tune the anchor boxes to get estimates for the bounding box - the ground truth boxes and IoU metric is used for this. The authors claim that this design is simple enough to allow the focal loss to show it's power.\n\n```\nQuestion: If the network as well as the loss function are being changed - then doesn't this make it hard to ensure the changes are orthogonal and not interfering and impacting the results?\n```\n\n#### Figure 4\n\nThis graph shows the q-q plot or CDF of normalized loss against the CDF of sample, for each of foreground(object) and background (no object) examples from the ResNet-101 predictions, at different values of gamma for Focal Loss (including Cross Entropy Loss).\n\nThis graph is used to identify that the loss on \n\n\n```\nnormalized loss: I guess this is the normalized cost function\nCDF to CDF - p-p plot.\n```\n\nActually, reading the section for this figure - I don't get this section well - there is the dataset, the model, some normalization of loss, splits into unbalanced foreground and background labels, quite a lot that needs to be teased out. I will come back to this on the third or fourth pass.\n\n\n#### Figure 5\n\nThis graph and the following two are used to show that a similar function to the Focal Loss (FL), $FL^*$ (which depends on a $\\beta$ as well as $\\gamma$ parameter) is close to FL. \n\n```\nThere is no proper rigorous analysis, but empirical results and plots - is this good enough?\n```\n\n\n#### Figure 6\n\nFigure 6 show the derivatives are similar in nature and magnitude for FL and $FL^*$.\n\n#### Figure 7\n\nThis shows the effective variations of the parameters $\\beta$ and $\\gamma$ such that the loss function has desired behavior. It also shows less desirable loss functions in light black lines vs the better loss functions in heavier blue lines.\n\n\n## Introduction and Conclusion\n\n### 1. Introduction\n\nThe benchmark data set for researchers working on the object detection task is MS COCO (or COCO).\n\nThe reference metric is AP (Average Precision).\n\n```\nNeed to find references and blog posts on AP\n```\n\nState Of The Art (SOTA) object detectors on the AP (average precision) metric are all from a family of sparse object detectors that rely on two stage (proposal then classification+localization) technologies. \n\nAlthough their performance is to be applauded (still not good enough for many production applications) these two stage detectors are quite slow - as measured in Frames Per Second, FPS.\n\nA promising direction has been the development of one stage detectors, they run one order of magnitude faster (7 FPS for `Faster R-CNN` two stage detector vs 21 FPS for `YOLO Fast` using VGG-16 as a CNN feature extractor). However the performance of one stage detectors has lagged significantly (73.2 - `Faster R-CNN` vs 66.4 `YOLO Fast` AP).\n\nThis paper introduces a few technologies that demonstrate a one stage detector with comparable speed to SOTA one stage detectors for speed and comparable AP as SOTA two stage detectors - what they call an upper envelope of performance. The authors assert that the main driver of this improved performance is their new loss function - which combats extremely imbalanced foreground/background data in one stage detectors. (The authors believe extremely imbalanced foreground/background data this to be the impediment to better one stage detector performance).\n\nAlthough two stage detectors also see class imbalance, it is less severe and can be remedied by:\n\n- sampling heuristics (fixing the imbalance ratio by sampling)\n- online hard example mining (OHEM is a technique applied inside a minibatch to only select *high loss function* examples from the minibatch forward pass and use them in the backward pass)\n\nImbalance is less of an issue for two stage detectors because the first stage proposals are chosen as very likely to have foreground objects - most two stage detectors only present 1-2k proposal regions. \n\nOne shot detectors need to deal with orders of magnitude more locations that can be overlapping densely covered with many aspect ratios. As a consequence imbalances of 1000 to 1 are normal in background/foreground object classes. At training time this imbalance dominates the loss function, enough that effective learning for the foreground object classes doesn't happen. \n\nStrategies like sampling and OHEM can help but are not as efficient because the training algorithm still concentrates weight changing efforts on the easily classified background examples - there are so many more background examples due to the imbalance.\n\nTypically treatment for this imbalance is to use:\n\n- bootstrapping the dataset to create a distribution of parameters and averaging the resultant probabilities.\n\n- hard example mining (produce many data augmented examples possibly via crops/reflections of mis-classifications from prior training -foregrounds predicted as backgrounds - so that algorithm becomes better at learning these mappings.)\n\n\nThe authors believe their novel loss function alleviates the imbalance problem - by down-weighting easy examples and up-weighting hard examples. The exact form of the loss function is not important - the authors show that similar functions work.\n\nTo show how good the focal loss function is, the authors produced a one stage learning algorithm with many state of the art innovations (FPN backbone, ResNet) - called RetinaNet. It's performance of 5 FPS and very good AP of 39.1 - by comparison YOLOv2 achieves 21.2 AP, with undocumented speed.\n\n### 6. Conclusion\n\nThe authors reiterate that the problem with one stage detector AP performance has been extreme background/foreground class imbalance. \n\nThey present a modulating term applied to the cross entropy loss to create a new focal loss function. They believe this is a high quality solution as it results a better detector. The authors are pleased with a new one stage detector network trained using this focal loss, one that is better on speed and accuracy metrics.\n\n\n## All Remaining Section (except the Mathematics)\n\n### 2. Related Work\n\n**Classic Object Detectors**\n\nThere have some old school object detectors, starting around 2001, including:\n\n**Viola-Jones** was the first set of algorithms to produce useful results for object detection - applied to face recognition. Essentially taking rectangles and matching them to eyes, cheeks, nose and mouth, features are extracted. Then a boosting algorithm of the adaBoost variety is applied to these features to detect faces. **LeCun's** seminal paper proposed sliding windows to detect characters. **Histogram of Oriented Gradients** of integral channels produced good results for pedestrian detection - essentially finding edges in images, again powered by sliding windows. With the onset of Deep Learning, these fell behind in SOTA performance. \n\n**Two Stage Detectors** have been suggested by some of the authors of this paper. They have pioneered innovations and improvements in this space. The main idea is to propose a smaller number of regions (relative to sliding windows) where the propasal step is done so each region has a high probability of having a foreground object class. Then a feature extractor CNN is used to get features and then a classifier and located at most one object class in each region proposal. \n\nThe first iteration of the methodology R-CNN using a fixed method - they used selective search algorithm was used for the region proposal, CNN feature extractor run on this and then SVMs used classify objects, and regression head to get the bounding boxes. However, this was slow.\n\nLater this improved by using the faster R-CNN algorithm. This would move things around a little and change the SVM. An image is processed by a CNN feature extractor, then the region proposal takes place, then this is fed into a CNN which outputs two heads - a classifier using a fully connected layer and a bounding box regression, both of which take the CNN as input.\n\nThis was still too slow for many applications. So, Faster R-CNN algorithm was proposed. With this algorithm, the region proposal step is also trained using a CNN, using a IoU criteria to train region finding - taking input from a CNN feature extractor network that is pre-trained. Then the rest follows as before for the fast R-CNN algorithm.\n\nThere have been several extensions since then to the same basic idea - first classify/set regions likely to have foreground objects, then classify and regress bounding boxes on them.\n\n**One Stage Detectors**\n\nOne stage detectors are all from the dense object detector family. They propose several orders of magnitude more regions - using anchors has been a key insight. Then they finesse the bounding boxes around these anchors and classify the object contained. Among those that have been suggested are:\n\n- OverFeat\n- SSD\n- YOLO\n\nThey all are highly performant on speed, but lag accuracy materially compared to two stage detectors.\n\nRetinaNet is a one stage detector taken from this family of dense detectors using FPN for the scaling to boost performance. It achieves higher accuracy and maintains speed by having the novel loss function - focal loss. \n\n**Class Imbalance**\n\nThe one stage detectors suffer from extreme imbalance, $~10^5$ regions. This poses two problems:\n\n- overwhelming the cost function at training time with easy negative (background) classifications \n- inefficient estimation as most regions produce no signal\n\n\nHard negative mining has been the traditional solution. Other more complex re-sampling strategies can be used.\n\nThe central theme of this paper, focal loss is shown to be good at dealing with such imbalance.\n\n**Robust Estimation**\n\nRobust Loss functions have been used to down-weight or reduce the influence of outliers - outliers being determined by their frequency in the data. This paper instead focuses on down-weighting or reducing the impact of easy examples - even if they are the majority of the imbalanced data. \n\n### 3. Focal Loss\n\nTraditional cross entropy loss is given in equation 1. It is the average number of bits needed to learn the outcome of a random draw from the true distribution. One can also think of it as a measure how different the true distribution q is from the distribution being used p.\n\nOne hot data vectors are used as instances to compute the cross entropy for data against a model distribution. Then this averaged cross entropy function is the cost function which is usually run through an optimization algorithm (often from the gradient descent family of optimizers) to find the best parameters that minimize the cost.\n\nBy minimizing the cross entropy function, we can get a best fit. This also reduces the NLL of MLEs for classifiers.\n\n#### 3.1 Balanced Cross Entropy\n\nAlthough the above is a good strategy, the reality is that sometimes we come across imbalanced data in classification tasks. For example our current case of dense object detection. What this imbalance does is make it very difficult for gradient descent algorithms to find a good local optima. The reason is that the class(es) with the highest frequency contribute so much more to the loss function, that they dominate the loss function and the other examples are not concentrated on enough by the loss function optimizer.\n\nUsually re-sampling strategies are run to artificially add more examples of the lower/least frequency classes. This can be done through:\n\n- over-sampling the lower frequency classes\n- under-sampling the higher frequency classes\n- setting a weight hyper-parameter to increase the contribution of the lower frequency classes and/or reduce the contribution of the higher frequency classes.\n\nEquation (3) lists the expression for the last of these strategies - in a compacted form.\n\n#### 3.2 Focal Loss Definition\n\nThe tunable focal loss equation is introduced in equations 4 (one parameter) and 5 (two parameter). Somewhat strange, but at training time an approximation to this is used.\n\nThe authors outline how the focal loss has the desired property of reducing the loss of misclassifying high probability classes (such as background) and increasing the loss of misclassifying more complicated examples.\n\n#### 3.3 Class Imbalance and Model Initialization\n\nWith extreme class imbalance of around $10^3-10^6$ to 1, the usual parameter initialization strategy for binary classification leads to unstable training early on for focal loss. The authors suggest instead giving initial conditions that corresponds to 0.01 probability for the foreground (lower frequency) class. They even call this a prior - which it doesn't feel like in a Bayesian sense - but given that neural networks can have many local optima - perhaps it is like a Bayesian prior, in that it impacts the parameter choices and final probability estimates.\n\n#### 3.4 Class Imbalance and Two Stage Detectors\n\nClass imbalance is less of an issue for two stage detectors because of the proposal layer, that filters for likely regions. There are still 1000-2000 proposal locations usually. Of these, again many will not have a foreground object. However, the regions are proposed to be much more likely to have a foreground object. This helps reduce the class imbalance. Secondly at training time, the minibatches are constructed to have reasonable ratios of classes - say 1:3, effectively re-sampling within the minibatches.\n\nThe authors note this is like re-weighting the terms of the loss function with a $\\alpha$ weight hyperparameter.\n\nBy contrast the focal loss function works at a different level of abstraction.\n\n```\nIt would have been interesting to see how focal loss does with two stage detectors.\n```\n\n### 4. RetinaNet Detector\n\n**Feature Pyramid Network**\nGiven a single image input resolution, it is normal that some objects are at very different scales to others. In that case, performance can be improved by having classification go through a range of scales. A Feature Pyramid Network is a collection of layers that achieves this. It works as follows:\n\n- lateral connections are made from the convolutional layers to each scale layer of the pyramid.\n\n- top down connections feed into the scale layers through the convolutions.\n\n- the scale layers connect to their own classification and box sub networks. \n\nThese then feed into the final set of classification and bounding box predictions.\n\nScale layer $P_l$ reduces input resolution by by a factor $2^l$.\n\n**Anchors**\n\nDefault boxes, or anchors are spaced out across the image data. They then assign to a K hot vector of classifications and probabilities and the bounding box regression. These anchors are presented at the various scales corresponding to the FPNs.\n\n**Classification Subnets**\n\nThis head predicts the classification probability for each of the classes for each anchor box.\n\n**Box Regression Subnet**\n\nThis finesses the anchors box to get the bounding box for each object in the anchor box.\n\n#### 4.1 Inference and Training\n\n**Inference**\n\nThis is a FCN with two heads per bounding box, a classification head and a bounding box regression head. The architecture includes the backbone FPN and a CNN extractor.\n\nTo improve speed of training, after some threshold only the top 1000 detected objects are used to continue training on. Non-max suppression is used when at a threshold of 0.5 to keep only the most promising predictions.\n\n**Focal Loss**\n\nThe authors found in their hyperparameter tuning that focal loss with $\\gamma = 2$, $\\alpha = 0.25$, worked best. They suggest reducing $\\alpha$ as $\\gamma$ is increased.\n\n**Initialization**\n\nThe hidden layers were initialized with the usual bias being 0 and small variance ($\\sigma=0.01$) random gaussian noise.\n\nFor the final layer of the classification head, the bias parameter is set as the inverse logit of 0.01. \n\n**Optimization**\n\nminibatch (16 images) stochastic gradient descent using GPUs is used to train RetinaNet for 90000 iterations and decaying learning parameter. Focal loss is used for the classification part and L1 loss for the bounding box regression. They trained for around 35 hours.\n\n\n### 5. Experiments\n\nTraining is done on 40k images with some randomized selection from the dataset. The test-dev set is found for data where no public labels are given and the test-dev features are tested and predicted on using an evaluation server.\n\n#### 5.1 Training Dense Detection\n\n**Network Initialization**\nIf the usual initialization techniques are used, the network diverges. However, the earlier outlined strategy of using the prior probs of 0.01 and inverse logit to get bias parameters of the final layer of the network, make it converge to good AP values. This is all for the cross entropy loss.\n\n**Balanced Cross Entropy**\n\nWeighted or balanced cross entropy loss with $\\alpha=0.9$ gives the best results.\n\n**Focal Loss**\nThe hyperparameter search worked as explained above. The table shows a range of values used.\n\n**Analysis of the Focal Loss**\n\nThis section is important as it shows that the FL reduces the loss for all but the most extreme negative background examples contribute to the FL over the dataset. That is, the majority of background easy classifications do not contribute very much to the loss function.\n\nI feel some other kind of chart could be used to indicate this - maybe plotting the cumulative loss function cumulatively against the probability estimate of the foreground and background classes.\n\n**Online Hard Example Mining**\n\nOHEM discards the easy examples and has the loss function optimized on the hard examples that were misclassified - this happens inside the gradient descent algorithm where examples are included or discarded. Note that focal loss still keeps the easy examples, but reduces their effect on the loss function. \n\nThe authors note that the AP was higher (better) for focal loss by 3.6 points than OHEM.\n\n**Hinge Loss**\n\nLin et al. tried to train with hinge loss - setting loss to zero after a certain threshold, but it didn't work producing unstable results that didn't converge. \n\n#### 5.2 Model Architecture Design\n\n**Anchor Density**\nHow high a density to have for for the anchors and possibly having the same anchor locations for different tall and wide boxes is not an exact science, but impacts performance a great deal for one stage detectors. The authors find that after a certain density, increasing the number and spread of anchors doesn't help performance.\n\n**Speed Vs Accuracy**\n\nFaster networks need smaller backbone networks. The speed accuracy tradeoff is show in the figures. it shows an upper envelope of better accuracy and faster speed compared to most models that are at the SOTA. \n\n\n### 5.3 Comparison to State of the Art\n\nThe authors reiterate their faster and more accurate model over a range of backbone networks. They show exact numbers.\n\n\n## Everything Else\n\n### Mathematics\n\n#### Equation 1\n\nUnder this binary regime either $y=1$ or $y=-1$ are the two classes.\n\n$$\n\\begin{equation}\n CE(p,y) = \\left \\{\n \\begin{aligned}\n &-\\log(p), && \\text{if}\\ y=1 \\\\\n &-\\log(1-p), && \\text{if}\\ y=-1 \n \\end{aligned} \\right.\n\\end{equation} \n$$\n\nThis is the equation for cross entropy loss for a binary classifier - it is the average number of bits needed under assumed probability distribution $p$ to identify an event drawn using the true distribution of $y$.\n\nThis is the natural loss function for binary classification and nicely links to MLE estimation/NLL cost function.\n\n#### Equation 2a\n\n$$\n\\begin{equation}\n p_t \\left \\{\n \\begin{aligned}\n & p, && \\text{if}\\ y=1 \\\\\n & 1-p, && \\text{if}\\ y=-1 \n \\end{aligned} \\right.\n\\end{equation} \n$$\n\nThis equation is a little odd because, there is no index or variable $t$ being referenced by the subscript. It might have been better to replace that with something $\\tilde{p} = \\tilde{p}(p,y)$, to keep a relation with p and indicate that it is transform of $p$ and $y$.\n\nOne way that it makes sense to keep the subscript t notation is if we were looking at multiclass classification. In that case,\n\n$$\n\\begin{equation}\n p_t \\left \\{\n \\begin{aligned}\n & p(y_t), && \\text{if}\\ y=y_t \\\\\n & 1-p(y_t), && \\text{if}\\ y \\neq y_t \n \\end{aligned} \\right.\n\\end{equation} \n$$\n\nHowever, even then this is messy notation.\n\n#### Equation 2a\n\nFrom the equation above we can rewrite $CE(p, y) = CE(p_t) = − log(p_t)$, keeping the same odd subscript $t$ notation.\n\n#### Equation 3\n\n$CE(p_t) = -\\alpha_t log(p_t)$\n\nThis is an equation made to put weight ($\\alpha_t \\in [0,1]$) to increase or decrease the cost of different outcomes. It's making adjustments (unnatural from some perspectives) to the cross entropy loss function.\n\nThis is a well known practice for dealing with imbalanced data.\n\nIn fact, note that this can be expressed as:\n\n$CE(p_t) = - log(p_t^{\\alpha_t})$\n\nNow if we have $y_0 = 1$ and $y_1 = -1$ (so $t=0$ or $t=1$) for the binary case, then in order to be consistent probability distributions in this representation we need:\n\n$(1-p_0)^{\\alpha_1} + p_0^{\\alpha_0} = 1$\n\nThis follows because $p_1 = 1 - p_0$.\n\nwhich we can write as saying that $\\alpha_0$ is free to be any value in [0,1], but that the following must hold - for probability consistency:\n\n${\\alpha_1} = \\frac{1- p_0^{\\alpha_0}}{log(1-p_0)}$\n\nWith a similar constraint existing if we extend to multiclass classification. \n\nThe effect is to increase the probability $p_0$ and decrease the probability $p_1$ with a functional form that does not depend on the weights or features of the network. If we assigned foreground images to the label $y_0=1$, then it makes sense to upweight the class with fewer examples.\n\nIf this modification was acting on the weights, then it would be called a regularizer, or a flat Bayesian prior. But since it is at the level of the loss function we don't call it that but the effect is similar.\n\n\nOf course one downside is that we need to use hyperparameter tuning to find the best value of the loss function weight parameter.\n\n#### Equation 4\n\nThe central topic of this paper is the tunable focal loss, given by the equation:\n\n$FL(p_t) = −(1 − p_t)^{\\gamma} log(p_t)$\n\nfor $\\gamma \\geq 0$. \n\nThe authors find that in practice the exact choice of gamma does not affect much the accuracy. They suggest $\\gamma \\in [2,5]$ for good tuning results based on their experiments.\n\nLet's do our analysis of this function via Taylor series. Using $log(x) \\approx (x-1) - (1/2)(x-1)^2$ for small enough x, well then:\n\n$FL(p_t) \\approx −(1 − p_t)^{\\gamma} ((p_t-1) - ^2)$\n\n$ = −(1 − p_t)^{\\gamma} ((p_t-1) - (1/2)(p_t^2- 2*p_t + 1))$\n\n$ = −(1 − p_t)^{\\gamma} (1/2)(p_t-1)(3 - p_t)$\n\n$ = (1/2)(1 − p_t)^{\\gamma + 1 }(3 - p_t)$\n\nThere is no real insight to be had from this expansion, but it might have been useful.\n\n\nThis $FL$ function is still pinned at 0 and infinity for perfect and worst fit to the one hot vector of actual observation y to distribution estimated via $p_t$. What it does however, is to lower the loss for good estimations ($p_t$ close to y) and increase the loss for bad estimation ($p_t$ far from $y$). \n\nIn effect, the focal loss is applying a modulating factor to the cross entropy loss. This might be seen as a kind of flat Bayesian prior, or regularizer to encourage the kind of fit that does well for imbalanced data. Only this flattening is not at the level of the weights, but higher up in the model, acting at the loss function level.\n\n```\nThere is something not satisfying that the true probabilities cannot be estimated well due to imbalanced data, so much so that we need to resort to modifying the cross entropy loss function using heuristics. \n\nThe hope would be to have methods which deal with imbalance at a lower level, at the parameter or architecture level. The reason I believe this to be important is that the cross entropy function is well understood with connections to maximum likelihood estimation. To introduce extra parameters - some of which might be better pushed down the network parameter estimation level feels wrong.\n\nHowever, since focal loss produces state of the art results we should applaud it's contribution to the field. It also is specifically used for data imbalance - where other strategies have failed to get solutions efficiently. Also, it is not post processing the estimated probabilities - but directly optimizing them, albeit in a novel way.\n\nPerhaps it is time to consider others families of loss functions.\n```\n#### Equation 5\n\nIn practice the authors suggest that a weight factor applied to the modulated loss function produces good results. So one could express focal loss as:\n\n$FL(p_t) = -\\alpha_t (1 − p_t)^{\\gamma} log(p_t)$\n\nNow with two tunable parameters.\n\n```\nLet's see what happens if we try to express the probability model implied by this loss - for the binary case:\n```\nSay, we set:\n\n$$ \\phi_t = -\\alpha_t (1 − p_t)^{\\gamma} log(p_t)$$\n\nThen:\n\n$$ exp(- \\frac{\\phi_t}{\\alpha_t} (1 − p_t)^{-\\gamma}) = p_t$$\n\nreplacing the ratio $\\frac{\\phi_t}{\\alpha_t} = \\Gamma_t$\n\n$$ exp( - \\Gamma_t (1 − p_t)^{-\\gamma}) = p_t $$\n\n```\nSo as we are optimizing the loss function, we are restricting the solution to be on a level set with the form above. I wonder if constrained optimization could be used, maybe not relevant\n```\n\n#### Equation 6\n\nThis and the following two equations are in the appendix and are supposed to show that there is a easier to optimize function that is very similar to the focal loss described earlier.\n \n$x_t = yx$\n\nIt really isn't clear what x is supposed to represent. It may just be that for any scalar $x$, we denote by $x_t$ the product of $y$ and $x$. We are told that $y \\in {-1,1}$ is the ground truth label. I initially thought $x$ was a reference to the features $x$, but that doesn't seem to be the case. We are also told that \n\n$p_t = \\sigma(x_t)$\n\nis compatible with equation 2. There isn't an explicit definition of $\\sigma(\\cdot)$. I had thought that it might be the sigmoid function. However matching up the earlier definition from equation 2\n\n$$\n\\begin{equation}\n p_t \\left \\{\n \\begin{aligned}\n & p, && \\text{if}\\ y=1 \\\\\n & 1-p, && \\text{if}\\ y=-1 \n \\end{aligned} \\right.\n\\end{equation} \n$$\n\nit's hard to tell. So, let's investigate:\n\n$p_t = \\sigma(x_t) = \\sigma(yx)$ is to be $p$ if $y=1$ and $1-p$ if $y=-1$.\n\nAgain, it's difficult to be sure. So what we'll do it look further ahead at equation 9. From this, we can see that the differential equation can be evaluated only if $\\sigma(\\cdot)$ is the sigmoid function. It would have been nice if the authors had made this explicit.\n\n\n#### Equation 7\n\n$p_t^{∗} = \\sigma(\\gamma x_t + \\beta)$\n\n#### Equation 8\n\n$FL∗ = − \\frac{log(p_t^{∗})}{\\gamma}$\n\nThe authors assert that $FL^{*}$ for the settings of $\\gamma=2$ and $\\beta=1$ is very close to FL and computationally easier. The show graphs where the function is similar within a good range.\n\n```\nQuestion: As neural networks are excellent function approximators, I'm inclined to wonder why they couldn't just approximate these specific transformations. Perhaps the extra help is needed because of the overwhelming imbalance. \n```\n\n#### Equation 9\n\n$\\frac{dCE}{dx} = y(p_t − 1)$\n\nThis equation only works if $\\sigma(\\cdot)$ is the sigmoid function. We'll do the arithmetic here:\n\n$CE = -log(p_t) = -log(\\sigma(x_t)) = -log(\\sigma(yx))$\n\n$\\frac{dCE}{dx} = -[\\sigma(yx)]^{-1} * \\frac{d[\\sigma(yx)]}{dx}$\n\n$ = -[\\sigma(yx)]^{-1} * \\sigma(yx) * [1- \\sigma(yx)] y$\n\n$= y(p_t − 1)$\n\n\n\nThe reason for giving this and the following two equations seems to be to allow parameter updates via gradient descent when training. In addition, they serve to demonstrate the closeness of $FL$ to $FL^*$, particularly with reference to the figures with the chosen values of the tuning parameters.\n\n#### Equation 10\n\n$\\frac{dF}{dx} = y(1 − p_t)^\\gamma (\\gamma p_t log(p_t) + p_t − 1)$\n\n#### Equation 11\n\n$\\frac{dFL^{∗}}{dx} = y(p_t^{*} − 1)$\n\n\n### Tables\n#### Table 1\n#### Table 2\n#### Table 3\n\n### Appendix\n#### Appendix A\n#### Appendix B\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "dd9f07115bb3d1b1caacdf5e0dd09a53cc161e0e", "size": 40514, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "papers/focal_loss_for_dense_object_detection_review.ipynb", "max_stars_repo_name": "project-delphi/object-detector", "max_stars_repo_head_hexsha": "0caf4f8c676f433286e99425baa2ad7c8350f711", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 8, "max_stars_repo_stars_event_min_datetime": "2019-06-16T22:44:50.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-23T17:11:27.000Z", "max_issues_repo_path": "papers/focal_loss_for_dense_object_detection_review.ipynb", "max_issues_repo_name": "project-delphi/object-detector", "max_issues_repo_head_hexsha": "0caf4f8c676f433286e99425baa2ad7c8350f711", "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": "papers/focal_loss_for_dense_object_detection_review.ipynb", "max_forks_repo_name": "project-delphi/object-detector", "max_forks_repo_head_hexsha": "0caf4f8c676f433286e99425baa2ad7c8350f711", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2022-01-23T17:11:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-23T17:11:41.000Z", "avg_line_length": 62.0428790199, "max_line_length": 659, "alphanum_fraction": 0.6749025028, "converted": true, "num_tokens": 7619, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3486451353339458, "lm_q2_score": 0.21206879439743004, "lm_q1q2_score": 0.07393675352279873}}
{"text": "# Chap_07_Nochapter\n## Comparison of Forward and Futures Contracts\nskipped...\n## Hedging\nskipped, still here though. ***Hedging***: *eliminate some or all of the risks*. We can hedge with **futures**, or even ***perfect hedge***, that if there's a future contract that trades:\n\n- exactly the asset we want to hedge\n- with the exact maturity we want to hedge\n\nOtherwise, ***asset mismatch*** or ***maturity mismatch***. Then, the solution is **cross-hedging**.\n\n## Cross-Hedging\nalso skipped, presented here though. Let \n$\n% color\n% Aquamarine, black, blue, brown, cyan, darkgray, gray, green, lightgray, lime, magenta, olive, orange, pink, purple, red, teal, violet, white, yellow\n\\DeclareMathOperator*{\\argmin}{argmin}\n\\DeclareMathOperator*{\\argmax}{argmax}\n\\DeclareMathOperator*{\\plim}{plim}\n\\newcommand{\\ffrac}{\\displaystyle \\frac}\n\\newcommand{\\d}[1]{\\displaystyle{#1}}\n\\newcommand{\\space}{\\text{ }}\n\\newcommand{\\bspace}{\\;\\;\\;\\;}\n\\newcommand{\\bbspace}{\\;\\;\\;\\;\\;\\;\\;\\;}\n\\newcommand{\\QQQ}{\\boxed{?\\:}}\n\\newcommand{\\void}{\\left.\\right.}\n\\newcommand{\\Tran}[1]{{#1}^{\\mathrm{T}}}\n\\newcommand{\\CB}[1]{\\left\\{ #1 \\right\\}}\n\\newcommand{\\SB}[1]{\\left[ #1 \\right]}\n\\newcommand{\\P}[1]{\\left( #1 \\right)}\n\\newcommand{\\abs}[1]{\\left| #1 \\right|}\n\\newcommand{\\norm}[1]{\\left\\| #1 \\right\\|}\n\\newcommand{\\given}[1]{\\left. #1 \\right|}\n\\newcommand{\\using}[1]{\\stackrel{\\mathrm{#1}}{=}}\n\\newcommand{\\asim}{\\overset{\\text{a}}{\\sim}}\n\\newcommand{\\RR}{\\mathbb{R}}\n\\newcommand{\\EE}{\\mathbb{E}}\n\\newcommand{\\II}{\\mathbb{I}}\n\\newcommand{\\NN}{\\mathbb{N}}\n\\newcommand{\\ZZ}{\\mathbb{Z}}\n\\newcommand{\\QQ}{\\mathbb{Q}}\n\\newcommand{\\PP}{\\mathbb{P}}\n\\newcommand{\\AcA}{\\mathcal{A}}\n\\newcommand{\\FcF}{\\mathcal{F}}\n\\newcommand{\\AsA}{\\mathscr{A}}\n\\newcommand{\\FsF}{\\mathscr{F}}\n\\newcommand{\\dd}{\\mathrm{d}}\n\\newcommand{\\I}[1]{\\mathrm{I}\\left( #1 \\right)}\n\\newcommand{\\N}[1]{\\mathcal{N}\\left( #1 \\right)}\n\\newcommand{\\Exp}[1]{\\mathrm{E}\\left[ #1 \\right]}\n\\newcommand{\\Var}[1]{\\mathrm{Var}\\left[ #1 \\right]}\n\\newcommand{\\Avar}[1]{\\mathrm{Avar}\\left[ #1 \\right]}\n\\newcommand{\\Cov}[1]{\\mathrm{Cov}\\left( #1 \\right)}\n\\newcommand{\\Corr}[1]{\\mathrm{Corr}\\left( #1 \\right)}\n\\newcommand{\\ExpH}{\\mathrm{E}}\n\\newcommand{\\VarH}{\\mathrm{Var}}\n\\newcommand{\\AVarH}{\\mathrm{Avar}}\n\\newcommand{\\CovH}{\\mathrm{Cov}}\n\\newcommand{\\CorrH}{\\mathrm{Corr}}\n\\newcommand{\\ow}{\\text{otherwise}}\n\\newcommand{\\wp}{\\text{with probability }}\n\\newcommand{\\FSD}{\\text{FSD}}\n\\newcommand{\\SSD}{\\text{SSD}} S_T^\\P1$ be the **spot price** of the asset at which the hedger has to deliver at time $T$; and $F_2\\P{t,U}$ be the **futures price** at time $t$ of the contract maturing at time $U$ on the asset $S^\\P2$, which will be used for **hedging**.\n\nThe hedger takes a *long position* in $\\delta$ units of the futures $F_2\\P{t,U}$. Here $\\delta$ is called the ***hedge ratio***. After hedging, we have the ***risk exposure*** $H$:\n\n$$H = S_t^\\P1 - S_T^\\P1 + \\delta\\P{F_2\\P{T,U} - F_2\\P{t,U}}$$\n\n- $S_t^\\P1 - S_T^\\P1$: the change in the value of the asset to be delivered at time $T$\n- $\\delta\\P{F_2\\P{T,U} - F_2\\P{t,U}}$: the payoff of holding the *long position* in the futures contract between $t$ and $T$.\n\nIdeally, $H=0$, meaning the perfect hedge.\n## Optimal $\\delta$\nskipped, interesting though.\n\n## Delta Neutral Strategy\nRisk exposure $H$ per one call option is $H = c\\P{0} - c\\P{T} +y\\P{S_T-S_0}$. Here the ***delta hedging*** means: *to hedge your position by holding the stock with the number of shares equal to the option's delta*.\n\nUnder the **single-period binomial tree** model, $H = x-xe^{rT}$, and with more periods, we can hedge dynamically. Then the **continuous-time** model, we define the ***Delta***:\n\n$$\\Delta_c \\equiv \\ffrac{\\partial c\\P{t,S_t}}{\\partial S_t}$$\n\nCommonly, an option written on an underlying asset $S$ is most sensitive to the changes in the value of $S$. Hence, the largest part of the risk comes from the price movements of asset $S$.\n\nAnd the **first order approximation** for $c$:\n\n$$c\\P{t,S_t} \\approx c\\P{0,S_t} + \\Delta_c\\P{S_t-S_0}$$\n\nThen the ***Delta*** of a portfolio: *the change in the value of the portfolio divided by the change in the value of the underlying asset*.\n\nAnd the position with a **Delta** of $0$ is called ***delta neutral***, meaning that the portfolio doesn't change if the price of the underlying asset changes.\n\n**e.g.**\n\nWe are short $c\\P{t,S_t}$ and we want to hedge the associated risk with respect to the movements of $S_t$ by holding a position in $S_t$. We should find the number of shares of $S_t$ we should hold, namely $y$, in the complete portfolio $\\Pi$ in order to make $\\Delta_\\Pi = 0$:\n\n$$\\Delta_\\Pi = -\\Delta_c + y \\times 1 = 0 \\Rightarrow y = \\Delta_c$$\n***\n\nA portfolio is called ***long*** (***short***) ***Delta*** if its **Delta** is positive, $\\Delta_\\Pi > 0$ (negative with $\\Delta_\\Pi < 0$), in which case its value will *increase* (*decrease*) if the value of $S_t$ increases, all other variables being constant.\n\n***Static Hedging***: The hedge is set up initially and *never adjusted*. That's exactly what we do under the **single-period binomial model**, where a perfect replication of a payoff $c\\P{T,S_T}$ is achieved by holding exactly $\\Delta_c$ shares of the underlying at the initial time. All the risk is eliminated keeping the portfolio **Delta-Neutral** under this model. This result is not necessarily true in other models. However in practice, $S_t$ changes frequently thus to neutralize the **Delta**, we need to adjust the number of shares of $S_t$ held in the portfolio. We called this the ***dynamic hedging*** strategy.\n\nAnd for the **perfect hedge**, rebalancing must take *continuously*. This requires that the model and its parameters are exactly correct.\n\n## Delta under the Black-Scholes Model\nThe **Black-Scholes-Mertion equation** is derived by setting up a **delta-neutral position** (*short* $1$ option and *long* $\\Delta_c$ shares of the stock) and arguing that the return on the position should be the *risk-free interest rate*.\n\nFor the European call option, BS equation gives\n\n$$c\\P{t,S_t} = S_t\\N{d_1} - Ke^{-r\\P{T-t}}\\N{d_2}\\\\\nd_{1,2} = \\ffrac{1}{\\sigma\\sqrt{T-t}}\\P{\\log\\ffrac{S_t}{K}+\\P{r\\pm\\ffrac{\\sigma^2}{2}}\\P{T-t}}$$\n\nand we have $\\Delta_c = \\N{d_1}$ and then using the put-call parity we have $\\Delta_p = \\N{d_1} -1$. What's more\n\n- $\\Delta_c > 0$: the **replicating** portfolio of the call, never goes short in the stock\n- $\\Delta_c < 1$: holding one share or more of the stock is *more than enough* to **hedge** the call option payoff.\n- $\\Delta_p < 0$: the **replicating** portfolio, of the put, never goes long in the stock\n- $\\Delta_p > -1$: holding one share or more of the stock is *more than enough* to **hedge** the put option payoff.\n\n## Option Sensitivities\n*Partial derivatives* of the portfolio value with respect to parameters are called ***Greeks***. The five standard **Greeks** for a *portfolio* with value $V$ are\n\n$$\\begin{array}{c|ccccc}\\hline\n\\text{name} & \\text{Delta} & \\text{Theta} & \\text{Gamma} & \\text{Vega} & \\text{Rho}\\\\ \\hline\n\\text{expression} & \\Delta = \\ffrac{\\partial V}{\\partial S_t} & \\Theta = \\ffrac{\\partial V}{\\partial t} & \\Gamma = \\ffrac{\\partial^2 V}{\\partial S_t^2} & {\\large\\nu} = \\ffrac{\\partial V}{\\partial \\sigma} & {\\large\\rho} = \\ffrac{\\partial r}{\\partial S_t}\\\\\\hline\n\\end{array}$$\n\n### $\\Theta$, derivative with respect to time\n**Theta** is sometimes referred to as the ***time decay*** of the portfolio.\n\n$$\\begin{align}\n\\Theta_c &= S_t\\mathcal{N}'\\P{d_1}\\ffrac{\\partial d_1}{\\partial t} - rKe^{-r\\P{T-t}}\\N{d_2}-Ke^{-r\\P{T-t}}\\mathcal N'\\P{d_2}\\ffrac{\\partial d_2}{\\partial t}\\\\\n\\Theta_p &= rKe^{-r\\P{T-t}}\\N{-d_2}-Ke^{-r\\P{T-t}}\\mathcal N'\\P{-d_2}\\ffrac{\\partial d_2}{\\partial t} + S_t\\mathcal{N}'\\P{-d_1}\\ffrac{\\partial d_1}{\\partial t} \n\\end{align}$$\n\nand using the facts that $S_t\\mathcal{N}'\\P{\\pm d_1} = Ke^{-r\\P{T-t}}\\mathcal{N}'\\P{\\pm d_2}$ and $\\ffrac{\\partial d_1}{\\partial t} = \\ffrac{\\partial d_2}{\\partial t} - \\ffrac{\\sigma}{2\\sqrt{T-t}}$ we have\n\n$$\\begin{align}\n\\Theta_c &= - \\ffrac{\\sigma}{2\\sqrt{T-t}}S_t\\mathcal{N}'\\P{d_1} - rKe^{-r\\P{T-t}}\\N{d_2}\\\\\n\\Theta_p &= - \\ffrac{\\sigma}{2\\sqrt{T-t}}S_t\\mathcal{N}'\\P{d_1} + rKe^{-r\\P{T-t}}\\N{-d_2}\n\\end{align}$$\n\nUsually $\\Theta$ is negative, since option tends to be less valuable.\n\n### $\\Gamma$, second order derivative with respect to asset price\nIf the *absolute value* of $\\Gamma$ is large, $\\Delta$ would be highly sensitive to the price of the underlying asset, meaning that adjustments to keep a portfolio **delta neutral** need to be made relatively frequently. \n\nAnd since $\\Delta_c = \\N{d_1}$ and $\\Delta_p = \\N{d_1}-1$, we have, for European call/put\n\n$$\\Gamma = \\ffrac{\\partial \\N{d_1}}{\\partial S_t} = \\mathcal{N}'\\P{d_1} \\ffrac{1}{\\sigma\\sqrt{T-t}}\\ffrac{1}{S_t}>0$$\n\nUp to this point, we can already draw two very useful conclusions.\n\n### Approximation\nUsing **Taylor Expansion**:\n\n$$\\begin{align}\nV\\P{t+\\Delta t,S_{t+\\Delta t}} &= V\\P{t,S_t} + \\Delta t \\ffrac{\\partial V\\P{t,S_t}}{\\partial t} + O\\P{\\P{\\Delta t}\n^2} + \\P{S_{t+\\Delta t} - S_t}\\ffrac{\\partial V\\P{t,S_t}}{\\partial S_t} \\\\\n&\\bspace + \\ffrac{1}{2}\\P{S_{t+\\Delta t} - S_t}^2 \\ffrac{\\partial^2 V\\P{t,S_t}}{\\partial S_t\\partial S_t}+\\cdots\\\\\n&\\approx V\\P{t,S_t} + \\color{brown}{\\Theta}\\Delta t + \\color{brown}{\\Delta} \\P{S_{t+\\Delta t} - S_t} + \\ffrac{1}{2}\\color{brown}{\\Gamma} \\P{S_{t+\\Delta t} - S_t}^2\n\\end{align}$$\n\nFurther, if the portolio is **Delta Neutral**, then\n\n$$V\\P{t+\\Delta t,S_{t+\\Delta t}} \\approx V\\P{t,S_t} + \\color{brown}{\\Theta}\\Delta t + \\ffrac{1}{2}\\color{brown}{\\Gamma} \\P{S_{t+\\Delta t} - S_t}^2$$\n\n### Reaching Gamma Neutral\nSuppose a **Delta Neutral** portfolio has $\\Gamma$ as its **Gamma**, and another traded opion has **Gamma** equal to $\\Gamma_T$. If the number of traded options added to the portfolio is $w_T$, gamma of the new portfolio is $w_T \\Gamma_T + \\Gamma$ and thus buying $w_T = -\\ffrac{\\Gamma}{\\Gamma_T}$ would lead to **Gamma Neutral**. \n\nHowever this changes the $\\Delta$ of the portfolio, we need to trade more shares to neutralize our $\\Delta$ after that.\n\n**e.g.**\n\nSuppose that a portfolio is **Delta Neutral** and has a $\\Gamma$ of $-3000$. The $\\Delta_c$ and $\\Gamma_c$ of a particular traded call option are $0.62$ and $1.50$, respectively. How to make the portfolio **Delta Neutral** and **Gamma Neutral**?\n\n> The portfolio can be made **Gamma Neutral** by including in the portfolio a *long position* of $-\\ffrac{\\Gamma}{\\Gamma_c} = -\\ffrac{-3000}{1.5} = 2000$ call option. However, the **Delta** of the portfolio will then change fram $0$ to $\\Delta_v = 2000\\times 0.62 = 1240$. Thus, $1240$ units of the underlying asset must be *sold* from the portfolio to keep it **Delta Neutral**.\n***\n\n***delta hedging error***: when the stock price moves from $S_{1}$ to $S_{2}$ the option price moves from $C_1$ to $C_2$, while **delta hedging** assumes that it moves to $C_2'$. The difference between $C_2$ and $C_2'$ is the **delta hedging error**.\n\n- **Delta neutrality** provides protection against *relatively small* stock price moves between rebalancing.\n- **Gamma neutrality** provides protection against *larger* movements in this stock price between hedge rebalancing.\n\n### $\\large\\nu$, derivative with respect to volatility\n\nFor a European call or put option, **Vega** is given by\n\n$$\\begin{align}{\\large{\\nu}} &= S_t \\mathcal N'\\P{d_1}\\ffrac{\\partial d_1}{\\partial \\sigma} - Ke^{-r\\P{T-t}}\\mathcal N'\\P{d_2}\\ffrac{\\partial d_2}{\\partial \\sigma}\\\\\n&= S_t \\mathcal N'\\P{d_1}\\ffrac{\\partial d_1}{\\partial \\sigma} - S_t \\mathcal N'\\P{d_1}\\P{\\ffrac{\\partial d_1}{\\partial \\sigma} - \\sqrt{T-t}}\\\\\n&= S_t \\sqrt{T-t} \\mathcal N'\\P{d_1}>0\n\\end{align}$$\n\nThus, both the European call and put prices *increase with increasing volatility*. And this doesn't violate our intuition. Higher volatility lead to a higher chance that the option may end up either **deeper in-the-money** or **deep out-of-the-money**, while there's no extra peanlty for the option to be deeper out-of-the-money but the payoff increases when the option expires deeper in the money.\n\n### $\\large\\rho$, derivative with respect to interest rate\n\n$$\\begin{align}\n{\\large\\rho}_c &= S_t \\mathcal N'\\P{d_1}\\ffrac{\\partial d_1}{\\partial r} + K\\P{T-t}e^{-r\\P{T-t}}\\N{d_2} - Ke^{-r\\P{T-t}}\\mathcal N'\\P{d_2}\\ffrac{\\partial d_2}{\\partial r}\\\\\n&= K\\P{T-t}e^{-r\\P{T-t}}\\N{d_2} + S_t \\mathcal N'\\P{d_1}\\ffrac{\\partial d_1}{\\partial \\sigma} - S_t \\mathcal N'\\P{d_1}\\P{\\ffrac{\\partial d_1}{\\partial \\sigma} - 0}\\\\\n&= K\\P{T-t}e^{-r\\P{T-t}}\\N{d_2} > 0\\\\\n{\\large\\rho}_p &= -K\\P{T-t}e^{-r\\P{T-t}} \\N{-d_2} < 0\n\\end{align}$$\n\nA *higher interest* rate lowers the present value of the cost of exercising the European call option at expiration (the effect is similar to the *lowering of the strike price*), in turn this increases the call price. Reverse effect holds for the put option price.\n\n***\n", "meta": {"hexsha": "9c67770a061e8ad1b925ba34d1f154168fb7d395", "size": 16681, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "FinMath/Models and Pricing of Financial Derivatives/Chap_07_Anonymous.ipynb", "max_stars_repo_name": "XavierOwen/Notes", "max_stars_repo_head_hexsha": "d262a9103b29ee043aa198b475654aabd7a2818d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2, "max_stars_repo_stars_event_min_datetime": "2018-11-27T10:31:08.000Z", "max_stars_repo_stars_event_max_datetime": "2019-01-20T03:11:58.000Z", "max_issues_repo_path": "FinMath/Models and Pricing of Financial Derivatives/Chap_07_Anonymous.ipynb", "max_issues_repo_name": "XavierOwen/Notes", "max_issues_repo_head_hexsha": "d262a9103b29ee043aa198b475654aabd7a2818d", "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": "FinMath/Models and Pricing of Financial Derivatives/Chap_07_Anonymous.ipynb", "max_forks_repo_name": "XavierOwen/Notes", "max_forks_repo_head_hexsha": "d262a9103b29ee043aa198b475654aabd7a2818d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-07-14T19:57:23.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-14T19:57:23.000Z", "avg_line_length": 57.7197231834, "max_line_length": 635, "alphanum_fraction": 0.5807205803, "converted": true, "num_tokens": 4244, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268346176374815, "lm_q2_score": 0.15610489351941398, "lm_q1q2_score": 0.0737882014670179}}
{"text": "```python\n#format the book\n%matplotlib inline\nfrom __future__ import division, print_function\nimport sys;sys.path.insert(0,'..')\nfrom book_format import load_style;load_style('..')\n```\n\n\n\n\n\n\n\n\n\n\n# Computing and plotting PDFs of discrete data\n\nSo let's investigate how to compute and plot probability distributions.\n\n\nFirst, let's make some data according to a normal distribution. We use `numpy.random.normal` for this. The parameters are not well named. `loc` is the mean of the distribution, and `scale` is the standard deviation. We can call this function to create an arbitrary number of data points that are distributed according to that mean and std.\n\n\n```python\nimport numpy as np\nimport numpy.random as random\n\nmean = 3\nstd = 2\n\ndata = random.normal(loc=mean, scale=std, size=50000)\nprint(len(data))\nprint(data.mean())\nprint(data.std())\n```\n\n 50000\n 3.00621596517\n 1.99696435477\n\n\nAs you can see from the print statements we got 5000 points that have a mean very close to 3, and a standard deviation close to 2.\n\nWe can plot this Gaussian by using `scipy.stats.norm` to create a frozen function that we will then use to compute the pdf (probability distribution function) of the Gaussian.\n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\nimport scipy.stats as stats\n\ndef plot_normal(xs, mean, std, **kwargs):\n norm = stats.norm(mean, std)\n plt.plot(xs, norm.pdf(xs), **kwargs)\n\nxs = np.linspace(-5, 15, num=200)\nplot_normal(xs, mean, std, color='k')\n```\n\nBut we really want to plot the PDF of the discrete data, not the idealized function.\n\nThere are a couple of ways of doing that. First, we can take advantage of `matplotlib`'s `hist` method, which computes a histogram of a collection of data. Normally `hist` computes the number of points that fall in a bin, like so:\n\n\n```python\nplt.hist(data, bins=200)\nplt.show()\n```\n\nthat is not very useful to us - we want the PDF, not bin counts. Fortunately `hist` includes a `density` parameter which will plot the PDF for us.\n\n\n```python\nplt.hist(data, bins=200, normed=True)\nplt.show()\n```\n\nI may not want bars, so I can specify the `histtype` as 'step' to get a line.\n\n\n```python\nplt.hist(data, bins=200, normed=True, histtype='step', lw=2)\nplt.show()\n```\n\nTo be sure it is working, let's also plot the idealized Gaussian in black.\n\n\n```python\nplt.hist(data, bins=200, normed=True, histtype='step', lw=2)\nnorm = stats.norm(mean, std)\nplt.plot(xs, norm.pdf(xs), color='k', lw=2)\nplt.show()\n```\n\nThere is another way to get the approximate distribution of a set of data. There is a technique called *kernel density estimate* that uses a kernel to estimate the probability distribution of a set of data. NumPy implements it with the function `gaussian_kde`. Do not be mislead by the name - Gaussian refers to the type of kernel used in the computation. This works for any distribution, not just Gaussians. In this section we have a Gaussian distribution, but soon we will not, and this same function will work.\n\n\n```python\nkde = stats.gaussian_kde(data)\n\nxs = np.linspace(-5, 15, num=200)\nplt.plot(xs, kde(xs))\nplt.show()\n```\n\n## Monte Carlo Simulations\n\n\nWe (well I) want to do this sort of thing because I want to use monte carlo simulations to compute distributions. It is easy to compute Gaussians when they pass through linear functions, but difficult to impossible to compute them analytically when passed through nonlinear functions. Techniques like particle filtering handle this by taking a large sample of points, passing them through a nonlinear function, and then computing statistics on the transformed points. Let's do that.\n\nWe will start with the linear function $f(x) = 2x + 12$ just to prove to ourselves that the code is working. I will alter the mean and std of the data we are working with to help ensure the numbers that are output are unique It is easy to be fooled, for example, if the formula multipies x by 2, the mean is 2, and the std is 2. If the output of something is 4, is that due to the multication factor, the mean, the std, or a bug? It's hard to tell. \n\n\n```python\ndef f(x):\n return 2*x + 12\n\nmean = 1.\nstd = 1.4\ndata = random.normal(loc=mean, scale=std, size=50000)\n\nd_t = f(data) # transform data through f(x)\n\nplt.hist(data, bins=200, normed=True, histtype='step', lw=2)\nplt.hist(d_t, bins=200, normed=True, histtype='step', lw=2)\n\nplt.ylim(0, .35)\nplt.show()\nprint('mean = {:.2f}'.format(d_t.mean()))\nprint('std = {:.2f}'.format(d_t.std()))\n```\n\nThis is what we expected. The input is the Gaussian $\\mathcal{N}(\\mu=1, \\sigma=1.4)$, and the function is $f(x) = 2x+1$. Therefore we expect the mean to be shifted to $f(\\mu) = 2*1+12=14$. We can see from the plot and the print statement that this is what happened. \n\nBefore I go on, can you explain what happened to the standard deviation? You may have thought that the new $\\sigma$ should be passed through $f(x)$ like so $2(1.4) + 12=14.81$. But that is not correct - the standard deviation is only affected by the multiplicative factor, not the shift. If you think about that for a moment you will see it makes sense. We multiply our samples by 2, so they are twice as spread out as before. Standard deviation is a measure of how spread out things are, so it should also double. It doesn't matter if we then shift that distribution 12 places, or 12 million for that matter - the spread is still twice the input data.\n\n\n\n## Nonlinear Functions\n\nNow that we believe in our code, lets try it with nonlinear functions.\n\n\n```python\ndef f2(x):\n return (np.cos((1.5*x + 2.1))) * np.sin(0.3*x) - 1.6*x\n\nd_t = f2(data)\nplt.subplot(121)\nplt.hist(d_t, bins=200, normed=True, histtype='step', lw=2)\n\nplt.subplot(122)\nkde = stats.gaussian_kde(d_t)\nxs = np.linspace(-10, 10, 200)\nplt.plot(xs, kde(xs), 'k')\nplot_normal(xs, d_t.mean(), d_t.std(), color='g', lw=3)\nplt.show()\nprint('mean = {:.2f}'.format(d_t.mean()))\nprint('std = {:.2f}'.format(d_t.std()))\n```\n\nHere I passed the data through the nonlinear function $f(x) = \\cos(1.5x+2.1)\\sin(\\frac{x}{3}) - 1.6x$. That function is quite close to linear, but we can see how much it alters the pdf of the sampled data. \n\nThere is a lot of computation going on behind the scenes to transform 50,000 points and then compute their PDF. The Extended Kalman Filter (EKF) gets around this by linearizing the function at the mean and then passing the Gaussian through the linear equation. We saw above how easy it is to pass a Gaussian through a linear function. So lets try that.\n\nWe can linearize this by taking the derivative of the function at x. We can use sympy to get the derivative. \n\n\n```python\nimport sympy\nx = sympy.symbols('x')\nf = sympy.cos(1.5*x+2.1) * sympy.sin(x/3) - 1.6*x\ndfx = sympy.diff(f, x)\ndfx\n```\n\n\n\n\n -1.5*sin(x/3)*sin(1.5*x + 2.1) + cos(x/3)*cos(1.5*x + 2.1)/3 - 1.6\n\n\n\nWe can now compute the slope of the function by evaluating the derivative at the mean.\n\n\n```python\nm = dfx.subs(x, mean)\nm\n```\n\n\n\n\n -1.66528051815545\n\n\n\nThe equation of a line is $y=mx+b$, so the new standard deviation should be $~1.67$ times the input std. We can compute the new mean by passing it through the original function because the linearized function is just the slope of f(x) evaluated at the mean. The slope is a tangent that touches the function at $x$, so both will return the same result. So, let's plot this and compare it to the results from the monte carlo simulation.\n\n\n```python\nplt.hist(d_t, bins=200, normed=True, histtype='step', lw=2)\nplot_normal(xs, f2(mean), abs(float(m)*std), color='k', lw=3, label='EKF')\nplot_normal(xs, d_t.mean(), d_t.std(), color='r', lw=3, label='MC')\nplt.legend()\nplt.show()\n```\n\nWe can see from this that the estimate from the EKF (in red) is not exact, but it is not a bad approximation either. \n", "meta": {"hexsha": "ba159565e7e16535a1984639af97a6a0ff693886", "size": 162737, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_stars_repo_name": "horaceheaven/Kalman-and-Bayesian-Filters-in-Python", "max_stars_repo_head_hexsha": "3639394a1218ab3e22e2c9929648d78586e52fe9", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 4, "max_stars_repo_stars_event_min_datetime": "2018-11-20T02:35:29.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-27T23:06:59.000Z", "max_issues_repo_path": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_issues_repo_name": "gokhanettin/Kalman-and-Bayesian-Filters-in-Python", "max_issues_repo_head_hexsha": "55d73b21de01ee4278cef1ab5b32405917f96287", "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": "Supporting_Notebooks/Computing_and_plotting_PDFs.ipynb", "max_forks_repo_name": "gokhanettin/Kalman-and-Bayesian-Filters-in-Python", "max_forks_repo_head_hexsha": "55d73b21de01ee4278cef1ab5b32405917f96287", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 6, "max_forks_repo_forks_event_min_datetime": "2017-08-30T05:28:46.000Z", "max_forks_repo_forks_event_max_datetime": "2020-06-23T07:08:42.000Z", "avg_line_length": 205.9962025316, "max_line_length": 22622, "alphanum_fraction": 0.8850292189, "converted": true, "num_tokens": 3971, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.43014736319616964, "lm_q2_score": 0.17106119801750536, "lm_q1q2_score": 0.07358152327240777}}
{"text": "「TransformerとTorchTextを用いたsequence-to-sequenceモデルの学習」\n===============================================================\n【原題】Sequence-to-Sequence Modeling with nn.Transformer and TorchText\n\n【元URL】https://pytorch.org/tutorials/beginner/transformer_tutorial.html\n\n【翻訳】電通国際情報サービスISID AIトランスフォーメーションセンター 御手洗 拓真\n\n【日付】2020年10月13日\n\n【チュトーリアル概要】\n\n本チュートリアルでは、Attention機構を備えたTransformerモジュールを使用したsequence-to-sequenceモデルの実装手法と訓練方法を解説します。\n\nWikiText2から取得した文章において、文章＝単語系列（sequence）を入力し、その次に来るであろう単語を予測するsequence-to-sequenceモデルを構築します。\n\n \n \n \n \n\n \n
\n\n---\n\n\n\n\n本ノートブックは、[nn.Transformer](https://pytorch.org/docs/master/nn.html?highlight=nn%20transformer#torch.nn.Transformer)モジュールを使用した、sequence-to-sequenceモデル学習の解説チュートリアルです。\n\nPyTorch 1.2 以降では、論文 [Attention is All You Need](https://arxiv.org/pdf/1706.03762.pdf)を基に実装された、標準的なTransformerのモジュールが用意されています。\n\n
\n\nTransformerモデルは、これまでのモデル（日本語訳注：RNN系）と比べてより並列化が容易であると同時に、多くのsequence-to-sequenceのタスクにおいて、より優れた結果が得られることが実証されています。\n\n\n\n\n`nn.Transformer`モジュールは、Attensionメカニズム（最近、\r\n[nn.MultiheadAttention](https://pytorch.org/docs/master/nn.html?highlight=multiheadattention#torch.nn.MultiheadAttention)として実装された別のモジュール）に完全に依存しています。このAttensionメカニズムにより、入力と出力の間の大域的な依存関係を捉えることができます。\r\n\r\n`nn.Transformer`モジュールは、単一でも使用しやすいように、高度にモジュール化されており、簡単に、`nn.Transformer`モジュールをコンポーネント（本チュートリアルの[nn.TransformerEncoder](https://pytorch.org/docs/master/nn.html?highlight=nn%20transformerencoder#torch.nn.TransformerEncoder)など）に適用したり、あるいは`nn.Transformer`モジュールを使って、コンポーネントを作成したりすることができます。\r\n\r\n
\n\n\n\nモデルの定義\n----------------\n\n\n本チュートリアルでは、言語モデルタスクで`NN.TransformerEncoder`モデルを訓練します。\n\nここでの言語モデルタスク（language modeling task）とは、特定の単語（または単語のシーケンス）が、与えられた単語シーケンスの後に続けて登場する確率を当てるタスクです。\n\n\n\n\n単語（トークン）のシーケンスは、最初にモデルの埋め込み層に渡され、その後、単語の順序の情報を得るための位置エンコーディング層（詳細は次の段落）へと渡されます。\r\n\r\n\r\n`nn.TransformerEncoder`は、複数の[NN.TransformerEncoderLayer](https://pytorch.org/docs/master/nn.html?highlight=transformerencoderlayer#torch.nn.TransformerEncoderLaye)の層で構成されています。\r\n\r\n言語モデルタスクでは、入力シーケンスと共に、アテンション・マスクが必要です。\r\n\r\nなぜなら、`NN.TransformerEncoder`のSelf-Attention層では、シーケンス内でより前方に登場するトークンのみに着目することが許されているためです。\r\n\r\n※日本語訳注：RNNでも単語は前から順番に入力され、後ろの単語は通常、考慮できないので、その状態を再現しています（後方からのシーケンスを利用する場合もありますが）。\r\n\r\n普通の日常会話でも、会話最中に、会話の先の内容を事前に聞くことはできない点と同じ状況です。\r\n\r\n\n\nそこで、言語モデルタスクでは、後方の位置にある単語（トークン）は未知のトークンとして扱うため、マスクする必要があります。\r\n\r\n正解の単語を求めるために、`NN.TransformerEncoder`モデルの出力は、最終的に全結合層に送られ、その後にlog-Softmax関数で処理されます。\n\n\n```python\n# 日本語訳注：追加\n%matplotlib inline\n!pip3 install torchtext==0.4.0\n```\n\n Collecting torchtext==0.4.0\n \u001b[?25l Downloading https://files.pythonhosted.org/packages/43/94/929d6bd236a4fb5c435982a7eb9730b78dcd8659acf328fd2ef9de85f483/torchtext-0.4.0-py3-none-any.whl (53kB)\n \u001b[K |████████████████████████████████| 61kB 8.1MB/s \n \u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.6/dist-packages (from torchtext==0.4.0) (1.18.5)\n Requirement already satisfied: tqdm in /usr/local/lib/python3.6/dist-packages (from torchtext==0.4.0) (4.41.1)\n Requirement already satisfied: torch in /usr/local/lib/python3.6/dist-packages (from torchtext==0.4.0) (1.7.0+cu101)\n Requirement already satisfied: requests in /usr/local/lib/python3.6/dist-packages (from torchtext==0.4.0) (2.23.0)\n Requirement already satisfied: six in /usr/local/lib/python3.6/dist-packages (from torchtext==0.4.0) (1.15.0)\n Requirement already satisfied: typing-extensions in /usr/local/lib/python3.6/dist-packages (from torch->torchtext==0.4.0) (3.7.4.3)\n Requirement already satisfied: dataclasses in /usr/local/lib/python3.6/dist-packages (from torch->torchtext==0.4.0) (0.8)\n Requirement already satisfied: future in /usr/local/lib/python3.6/dist-packages (from torch->torchtext==0.4.0) (0.16.0)\n Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext==0.4.0) (2020.12.5)\n Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext==0.4.0) (3.0.4)\n Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext==0.4.0) (1.24.3)\n Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests->torchtext==0.4.0) (2.10)\n Installing collected packages: torchtext\n Found existing installation: torchtext 0.3.1\n Uninstalling torchtext-0.3.1:\n Successfully uninstalled torchtext-0.3.1\n Successfully installed torchtext-0.4.0\n\n\n\n```python\nimport math\nimport torch\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nclass TransformerModel(nn.Module):\n\n def __init__(self, ntoken, ninp, nhead, nhid, nlayers, dropout=0.5):\n super(TransformerModel, self).__init__()\n from torch.nn import TransformerEncoder, TransformerEncoderLayer\n self.model_type = 'Transformer'\n self.src_mask = None\n self.pos_encoder = PositionalEncoding(ninp, dropout)\n encoder_layers = TransformerEncoderLayer(ninp, nhead, nhid, dropout)\n self.transformer_encoder = TransformerEncoder(encoder_layers, nlayers)\n self.encoder = nn.Embedding(ntoken, ninp)\n self.ninp = ninp\n self.decoder = nn.Linear(ninp, ntoken)\n\n self.init_weights()\n\n def _generate_square_subsequent_mask(self, sz):\n mask = (torch.triu(torch.ones(sz, sz)) == 1).transpose(0, 1)\n mask = mask.float().masked_fill(mask == 0, float('-inf')).masked_fill(mask == 1, float(0.0))\n return mask\n\n def init_weights(self):\n initrange = 0.1\n self.encoder.weight.data.uniform_(-initrange, initrange)\n self.decoder.bias.data.zero_()\n self.decoder.weight.data.uniform_(-initrange, initrange)\n\n def forward(self, src):\n if self.src_mask is None or self.src_mask.size(0) != src.size(0):\n device = src.device\n mask = self._generate_square_subsequent_mask(src.size(0)).to(device)\n self.src_mask = mask\n\n src = self.encoder(src) * math.sqrt(self.ninp)\n src = self.pos_encoder(src)\n output = self.transformer_encoder(src, self.src_mask)\n output = self.decoder(output)\n return output\n```\n\n`PositionalEncoding` モジュールは、シーケンス内のトークンの相対的な位置、もしくは絶対的な位置に関する情報をモデルに与えます。\n\n\n位置エンコーディング層（PositionalEncoding Layer）は、埋め込み層と同じ次元であり、位置エンコーディングの出力と、埋め込み層の出力は足し算することができます。\n\nここでは，異なる周波数のサイン波関数とコサイン波関数を使用し、位置エンコーディングを行っています。\n\n\n```python\nclass PositionalEncoding(nn.Module):\n\n def __init__(self, d_model, dropout=0.1, max_len=5000):\n super(PositionalEncoding, self).__init__()\n self.dropout = nn.Dropout(p=dropout)\n\n pe = torch.zeros(max_len, d_model)\n position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)\n div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))\n pe[:, 0::2] = torch.sin(position * div_term)\n pe[:, 1::2] = torch.cos(position * div_term)\n pe = pe.unsqueeze(0).transpose(0, 1)\n self.register_buffer('pe', pe)\n\n def forward(self, x):\n x = x + self.pe[:x.size(0), :]\n return self.dropout(x)\n```\n\nデータの読み込みとバッチ処理\n-------------------\n\n学習には`torchtext`のWikitext-2データセットを使用します。\n\nvocabオブジェクトは訓練データセットを元に構築され、トークン（単語）をテンソル形式の数値に変換するために使用されます。\n\n`batchify()` 関数は、シーケンス形式のデータ（トークンが左から右に一つずつ並んだ形）を、列が並んだ形式に変換します。変換する際には、データを``batch_size`` 変数のサイズで分割し、最後に余ったトークンは無視されます。\n\n例えば、アルファベットをシーケンス (長さ26) とし、バッチサイズを 4 とすると、アルファベットを長さ 6 の 4 つのシーケンスに分割したのが以下の例です。\n\n\\begin{align}\\begin{bmatrix}\n \\text{A} & \\text{B} & \\text{C} & \\ldots & \\text{X} & \\text{Y} & \\text{Z}\n \\end{bmatrix}\n \\Rightarrow\n \\begin{bmatrix}\n \\begin{bmatrix}\\text{A} \\\\ \\text{B} \\\\ \\text{C} \\\\ \\text{D} \\\\ \\text{E} \\\\ \\text{F}\\end{bmatrix} &\n \\begin{bmatrix}\\text{G} \\\\ \\text{H} \\\\ \\text{I} \\\\ \\text{J} \\\\ \\text{K} \\\\ \\text{L}\\end{bmatrix} &\n \\begin{bmatrix}\\text{M} \\\\ \\text{N} \\\\ \\text{O} \\\\ \\text{P} \\\\ \\text{Q} \\\\ \\text{R}\\end{bmatrix} &\n \\begin{bmatrix}\\text{S} \\\\ \\text{T} \\\\ \\text{U} \\\\ \\text{V} \\\\ \\text{W} \\\\ \\text{X}\\end{bmatrix}\n \\end{bmatrix}\\end{align}\n\n\n\n各列（=バッチ）は、モデル内では独立したものとして扱われます。そのため、例えば ``F`` と ``G`` の依存関係を学習することはできません。\r\n\r\n（日本語訳注：FとGは連続したアルファベットという依存関係がありますが、それはこの学習では考慮できないことになります）\r\n\r\n\r\nしかしながら、各バッチを独立したものとして扱うことで、より効率的なバッチ処理が可能になります。\n\n\n```python\nimport torchtext\nfrom torchtext.data.utils import get_tokenizer\nTEXT = torchtext.data.Field(tokenize=get_tokenizer(\"basic_english\"),\n init_token='
\n\n**入力シーケンスとTargetシーケンスを生成するための関数**\n\n``get_batch()``関数は，Transformerモデルの入力シーケンスと、Targetシーケンスを生成します。\n\nこの関数はソースデータを変数``bptt``の長さのチャンクデータに細分化します。\n\n 言語モデルのタスクでは、入力シーケンスに後続する単語がTargetとして必要となります。\n \n 例えば以下の図で、``bptt`` の値が 2 の場合、``i`` = 0 に後続する2 つの要素を取得します。\n\n
\n\n日本語訳注：bpttより2つの要素をinputに使用。\n\n下の図では、モデルへの入力（とあるタイミングで来た単語）とモデルが予測して欲しい出力（次のタイミングで来るべき単語）を表示しています。\n\n\n\n\n\n``get_batch()``関数の返り値``data``変数の 0 次元目 がチャンクの長さで、これはトランスフォーマーモデルの 次元``S``と一致していることに注意してください。\n\nまた、``data``変数の 1 次元目 はバッチサイズを示す次元数 ``N`` となっています。\n\n\n```python\nbptt = 35\ndef get_batch(source, i):\n seq_len = min(bptt, len(source) - 1 - i)\n data = source[i:i+seq_len]\n target = source[i+1:i+1+seq_len].view(-1)\n return data, target\n```\n\nインスタンスの初期化\n--------------------\n\nモデルは、以下のハイパーパラメータを使用して設定されます。vocabのサイズは、vocabオブジェクトの長さと同じです。\n\n\n```python\nntokens = len(TEXT.vocab.stoi) # the size of vocabulary\nemsize = 200 # embedding dimension\nnhid = 200 # the dimension of the feedforward network model in nn.TransformerEncoder\nnlayers = 2 # the number of nn.TransformerEncoderLayer in nn.TransformerEncoder\nnhead = 2 # the number of heads in the multiheadattention models\ndropout = 0.2 # the dropout value\nmodel = TransformerModel(ntokens, emsize, nhead, nhid, nlayers, dropout).to(device)\n```\n\nモデルの実行\n-------------\n\n\n\n\n[CrossEntropyLoss](https://pytorch.org/docs/master/nn.html?highlight=crossentropyloss#torch.nn.CrossEntropyLoss)は損失値を計算するために適用され、[SGD](https://pytorch.org/docs/master/optim.html?highlight=sgd#torch.optim.SGD)はオプティマイザとして使われる確率的勾配降下法です。\n\n初期の学習率は5.0に設定しています。\n\n\nエポック単位で学習率を調整するために[StepLR](https://pytorch.org/docs/master/optim.html?highlight=steplr#torch.optim.lr_scheduler.StepLR)__を使用します。\n\n訓練中は、勾配爆発を防ぐために、[nn.utils.clip_grad_norm](https://pytorch.org/docs/master/nn.html?highlight=nn%20utils%20clip_grad_norm#torch.nn.utils.clip_grad_norm_) 関数を用いて、全ての勾配をまとめた後、大きさをスケーリングしています。\n\n（日本語訳注：ここでのスケーリングとは、clip_grad_normで勾配が大きすぎる値は設定した上限値に変更するスケーリング操作を示します）\n\n\n```python\ncriterion = nn.CrossEntropyLoss()\nlr = 5.0 # 学習率\noptimizer = torch.optim.SGD(model.parameters(), lr=lr)\nscheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1.0, gamma=0.95)\n\nimport time\ndef train():\n model.train() # 訓練モードに\n total_loss = 0.\n start_time = time.time()\n ntokens = len(TEXT.vocab.stoi)\n for batch, i in enumerate(range(0, train_data.size(0) - 1, bptt)):\n data, targets = get_batch(train_data, i)\n optimizer.zero_grad()\n output = model(data)\n loss = criterion(output.view(-1, ntokens), targets)\n loss.backward()\n torch.nn.utils.clip_grad_norm_(model.parameters(), 0.5)\n optimizer.step()\n\n total_loss += loss.item()\n log_interval = 200\n if batch % log_interval == 0 and batch > 0:\n cur_loss = total_loss / log_interval\n elapsed = time.time() - start_time\n print('| epoch {:3d} | {:5d}/{:5d} batches | '\n 'lr {:02.2f} | ms/batch {:5.2f} | '\n 'loss {:5.2f} | ppl {:8.2f}'.format(\n epoch, batch, len(train_data) // bptt, scheduler.get_lr()[0],\n elapsed * 1000 / log_interval,\n cur_loss, math.exp(cur_loss)))\n total_loss = 0\n start_time = time.time()\n\ndef evaluate(eval_model, data_source):\n eval_model.eval() # 検証モードに\n total_loss = 0.\n ntokens = len(TEXT.vocab.stoi)\n with torch.no_grad():\n for i in range(0, data_source.size(0) - 1, bptt):\n data, targets = get_batch(data_source, i)\n output = eval_model(data)\n output_flat = output.view(-1, ntokens)\n total_loss += len(data) * criterion(output_flat, targets).item()\n return total_loss / (len(data_source) - 1)\n```\n\nエポックを繰り返します。\n\nその最中に、検証データの損失がそれまでの実行のなかで最も良い（低い）場合はモデルを保存します。\n\nそして、各エポックの後に学習率を調整し小さくします。\n\n\n```python\nbest_val_loss = float(\"inf\")\nepochs = 3 # The number of epochs\nbest_model = None\n\nfor epoch in range(1, epochs + 1):\n epoch_start_time = time.time()\n train()\n val_loss = evaluate(model, val_data)\n print('-' * 89)\n print('| end of epoch {:3d} | time: {:5.2f}s | valid loss {:5.2f} | '\n 'valid ppl {:8.2f}'.format(epoch, (time.time() - epoch_start_time),\n val_loss, math.exp(val_loss)))\n print('-' * 89)\n\n if val_loss < best_val_loss:\n best_val_loss = val_loss\n best_model = model\n\n scheduler.step()\n```\n\n /usr/local/lib/python3.6/dist-packages/torch/optim/lr_scheduler.py:370: UserWarning: To get the last learning rate computed by the scheduler, please use `get_last_lr()`.\n \"please use `get_last_lr()`.\", UserWarning)\n\n\n | epoch 1 | 200/ 2981 batches | lr 5.00 | ms/batch 18.01 | loss 7.99 | ppl 2946.49\n | epoch 1 | 400/ 2981 batches | lr 5.00 | ms/batch 16.62 | loss 6.79 | ppl 890.76\n | epoch 1 | 600/ 2981 batches | lr 5.00 | ms/batch 16.79 | loss 6.37 | ppl 582.28\n | epoch 1 | 800/ 2981 batches | lr 5.00 | ms/batch 16.73 | loss 6.24 | ppl 511.11\n | epoch 1 | 1000/ 2981 batches | lr 5.00 | ms/batch 16.73 | loss 6.12 | ppl 452.94\n | epoch 1 | 1200/ 2981 batches | lr 5.00 | ms/batch 16.74 | loss 6.09 | ppl 442.13\n | epoch 1 | 1400/ 2981 batches | lr 5.00 | ms/batch 16.81 | loss 6.05 | ppl 425.44\n | epoch 1 | 1600/ 2981 batches | lr 5.00 | ms/batch 16.81 | loss 6.04 | ppl 421.63\n | epoch 1 | 1800/ 2981 batches | lr 5.00 | ms/batch 16.86 | loss 5.95 | ppl 384.24\n | epoch 1 | 2000/ 2981 batches | lr 5.00 | ms/batch 16.83 | loss 5.96 | ppl 389.04\n | epoch 1 | 2200/ 2981 batches | lr 5.00 | ms/batch 16.87 | loss 5.85 | ppl 348.46\n | epoch 1 | 2400/ 2981 batches | lr 5.00 | ms/batch 16.87 | loss 5.89 | ppl 361.68\n | epoch 1 | 2600/ 2981 batches | lr 5.00 | ms/batch 16.88 | loss 5.90 | ppl 363.64\n | epoch 1 | 2800/ 2981 batches | lr 5.00 | ms/batch 16.91 | loss 5.81 | ppl 333.02\n -----------------------------------------------------------------------------------------\n | end of epoch 1 | time: 52.96s | valid loss 5.71 | valid ppl 301.92\n -----------------------------------------------------------------------------------------\n | epoch 2 | 200/ 2981 batches | lr 4.51 | ms/batch 17.01 | loss 5.81 | ppl 332.85\n | epoch 2 | 400/ 2981 batches | lr 4.51 | ms/batch 16.95 | loss 5.78 | ppl 322.99\n | epoch 2 | 600/ 2981 batches | lr 4.51 | ms/batch 16.99 | loss 5.60 | ppl 270.27\n | epoch 2 | 800/ 2981 batches | lr 4.51 | ms/batch 16.98 | loss 5.64 | ppl 281.97\n | epoch 2 | 1000/ 2981 batches | lr 4.51 | ms/batch 17.02 | loss 5.60 | ppl 269.70\n | epoch 2 | 1200/ 2981 batches | lr 4.51 | ms/batch 17.01 | loss 5.62 | ppl 276.25\n | epoch 2 | 1400/ 2981 batches | lr 4.51 | ms/batch 17.03 | loss 5.64 | ppl 281.10\n | epoch 2 | 1600/ 2981 batches | lr 4.51 | ms/batch 17.08 | loss 5.67 | ppl 289.51\n | epoch 2 | 1800/ 2981 batches | lr 4.51 | ms/batch 17.13 | loss 5.59 | ppl 268.94\n | epoch 2 | 2000/ 2981 batches | lr 4.51 | ms/batch 17.10 | loss 5.63 | ppl 277.96\n | epoch 2 | 2200/ 2981 batches | lr 4.51 | ms/batch 17.14 | loss 5.52 | ppl 249.62\n | epoch 2 | 2400/ 2981 batches | lr 4.51 | ms/batch 17.10 | loss 5.58 | ppl 265.00\n | epoch 2 | 2600/ 2981 batches | lr 4.51 | ms/batch 17.15 | loss 5.59 | ppl 268.33\n | epoch 2 | 2800/ 2981 batches | lr 4.51 | ms/batch 17.18 | loss 5.52 | ppl 248.84\n -----------------------------------------------------------------------------------------\n | end of epoch 2 | time: 53.46s | valid loss 5.56 | valid ppl 259.92\n -----------------------------------------------------------------------------------------\n | epoch 3 | 200/ 2981 batches | lr 4.29 | ms/batch 17.25 | loss 5.55 | ppl 256.28\n | epoch 3 | 400/ 2981 batches | lr 4.29 | ms/batch 17.22 | loss 5.56 | ppl 259.06\n | epoch 3 | 600/ 2981 batches | lr 4.29 | ms/batch 17.19 | loss 5.37 | ppl 215.03\n | epoch 3 | 800/ 2981 batches | lr 4.29 | ms/batch 17.21 | loss 5.42 | ppl 226.48\n | epoch 3 | 1000/ 2981 batches | lr 4.29 | ms/batch 17.19 | loss 5.38 | ppl 217.09\n | epoch 3 | 1200/ 2981 batches | lr 4.29 | ms/batch 17.20 | loss 5.42 | ppl 225.31\n | epoch 3 | 1400/ 2981 batches | lr 4.29 | ms/batch 17.19 | loss 5.44 | ppl 230.62\n | epoch 3 | 1600/ 2981 batches | lr 4.29 | ms/batch 17.15 | loss 5.48 | ppl 239.92\n | epoch 3 | 1800/ 2981 batches | lr 4.29 | ms/batch 17.20 | loss 5.41 | ppl 222.97\n | epoch 3 | 2000/ 2981 batches | lr 4.29 | ms/batch 17.21 | loss 5.44 | ppl 231.59\n | epoch 3 | 2200/ 2981 batches | lr 4.29 | ms/batch 17.22 | loss 5.32 | ppl 204.66\n | epoch 3 | 2400/ 2981 batches | lr 4.29 | ms/batch 17.20 | loss 5.39 | ppl 219.99\n | epoch 3 | 2600/ 2981 batches | lr 4.29 | ms/batch 17.24 | loss 5.42 | ppl 226.52\n | epoch 3 | 2800/ 2981 batches | lr 4.29 | ms/batch 17.37 | loss 5.34 | ppl 209.23\n -----------------------------------------------------------------------------------------\n | end of epoch 3 | time: 53.91s | valid loss 5.54 | valid ppl 254.24\n -----------------------------------------------------------------------------------------\n\n\nテストデータセットでモデルを評価する\n-------------------------------------\n\n結果を確認するために、ベストモデルでテスト用データセットを評価してみます。\n\n\n\n\n```python\ntest_loss = evaluate(best_model, test_data)\nprint('=' * 89)\nprint('| End of training | test loss {:5.2f} | test ppl {:8.2f}'.format(\n test_loss, math.exp(test_loss)))\nprint('=' * 89)\n```\n\n =========================================================================================\n | End of training | test loss 5.45 | test ppl 232.03\n =========================================================================================\n\n", "meta": {"hexsha": "d23a3a0ddb2bb731f5a8ee162e61c85a96429a6a", "size": 173831, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/3_NLP/3_1_transformer_tutorial_jp.ipynb", "max_stars_repo_name": "koseimori/pytorch_tutorials_jp", "max_stars_repo_head_hexsha": "a43397d1988a6f820044bd32474a55318253b932", "max_stars_repo_licenses": ["zlib-acknowledgement"], "max_stars_count": 114, "max_stars_repo_stars_event_min_datetime": "2020-12-18T05:13:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T04:36:50.000Z", "max_issues_repo_path": "notebook/3_NLP/3_1_transformer_tutorial_jp.ipynb", "max_issues_repo_name": "koseimori/pytorch_tutorials_jp", "max_issues_repo_head_hexsha": "a43397d1988a6f820044bd32474a55318253b932", "max_issues_repo_licenses": ["zlib-acknowledgement"], "max_issues_count": 15, "max_issues_repo_issues_event_min_datetime": "2021-01-01T01:33:57.000Z", "max_issues_repo_issues_event_max_datetime": "2021-10-14T04:20:46.000Z", "max_forks_repo_path": "notebook/3_NLP/3_1_transformer_tutorial_jp.ipynb", "max_forks_repo_name": "koseimori/pytorch_tutorials_jp", "max_forks_repo_head_hexsha": "a43397d1988a6f820044bd32474a55318253b932", "max_forks_repo_licenses": ["zlib-acknowledgement"], "max_forks_count": 21, "max_forks_repo_forks_event_min_datetime": "2020-12-26T00:31:00.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-28T23:32:25.000Z", "avg_line_length": 225.1696891192, "max_line_length": 89154, "alphanum_fraction": 0.8510162169, "converted": true, "num_tokens": 8353, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4649015713733885, "lm_q2_score": 0.1581743507642642, "lm_q1q2_score": 0.07353550422127196}}
{"text": "```python\nfrom IPython.display import HTML\n\nHTML('''\n''')\n```\n\n\n\n\n\n\n\n\n\n\n```python\nfrom IPython.display import HTML\n\nHTML('''\n\n\n\n''')\n```\n\n\n\n\n\n\n\n\n\n\n\n\n\n```python\nfrom IPython.display import HTML\n\nHTML('''{% include jupyter_benchmark_table.html num=\"[4]\" revision=0 %}''')\n```\n\n\n\n\n{% include jupyter_benchmark_table.html num=\"[4]\" revision=0 %}\n\n\n\n# Benchmark Problem 4: Linear Elasticity in 3D\n\nThe linear elastic energy of a body is\n\n\\begin{equation}\nE_{\\rm elastic}=\\frac{1}{2}\\int \\sigma_{ij}\\epsilon_{ij}\\,dV=\\frac{1}{2}\\int C_{ijkl}\\epsilon_{ij}\\epsilon_{kl}\\,dV,\n\\end{equation}\n\nwhere $\\sigma_{ij}=C_{ijkl}\\epsilon_{kl}$ is the stress, $C_{ijkl}$ is the elastic tensor, and $\\epsilon_{ij}$ is the strain,\n\\begin{equation}\n\\epsilon_{ij}=\\frac{1}{2}\\left[\\frac{\\partial u_i}{\\partial x_j}+\\frac{\\partial u_j}{\\partial x_i}\\right],\n\\end{equation}\nwith $u_i$ the displacement field. The indices $i,j,k,l$ run from 1 to 3, and $x_i,\\,i=1,2,3$, are Cartesian coordinates; we are using Einstein summation convention so repeated indices are summed over.\n\nThe elastic tensor obeys symmetries $C_{ijkl}=C_{jikl}=C_{ijlk}=C_{jilk}$ and $C_{ijkl}=C_{klij}$. These symmetries imply that there are only 21 independent entries in the elastic tensor. Usually Voigt notation is used, in which the four indices $ijkl$ are replaced by two indices $IJ$. The mapping for each pair $ij$ (or $kl$) is $11\\to1$, $22\\to2$, $33\\to3$, $23\\to4$ (and $32\\to4$), $13\\to5$ (and $31\\to5$), and $12\\to6$ (and $21\\to6$). The crystal symmetry may further reduce the number of independent entries. In an orthorombic crystal, there are only nine independent entries, and they are (in Voigt notation) $C_{11}, C_{22}, C_{33}, C_{44}, C_{55}, C_{66}, C_{12}, C_{13}$, and $C_{23}$. The tensor $C_{IJ}$ thus has the form\n\n\\begin{equation}\n\\left(\n\\begin{matrix}\nC_{11} & C_{12} & C_{13} & 0 & 0 & 0\\\\\nC_{12} & C_{22} & C_{23} & 0 & 0 & 0 \\\\\nC_{13} & C_{23} & C_{33} & 0 & 0 & 0 \\\\\n0 & 0 & 0 & C_{44} & 0 & 0\\\\\n0 & 0 & 0 & 0 & C_{55} & 0\\\\\n0 & 0 & 0 & 0 & 0 & C_{66}\n\\end{matrix}\n\\right).\n\\end{equation}\n\nFor tetragonal symmetry, there are six independent entries, $C_{11}, C_{33}, C_{44}, C_{66}, C_{12}$, and $C_{13}$. \n\nAluminum silicate, Al$_2$SiO$_5$ is a crystal with orthorombic symmetry and unit cell parameters $a=7.738\\;\\unicode{x212B}$ , $b=7.857\\;\\unicode{x212B}$, and $c=5.534\\;\\unicode{x212B}$. The elastic tensor is given by $C_{11}=233.4$, $C_{22}=289.0$, $C_{33}=380.1$, $C_{44}=99.5$, $C_{55}=87.8$, $C_{66}=112.3$; $C_{11}+C_{22}-2C_{12}=233.4$, $C_{11}+C_{33}-2C_{13}=380.9$, and $C_{22}+C_{33}-2C_{23}=506.3$, all in units of GPa.\n\n(a) (Potato in space) What is the equilibrium shape of a 0.0042~$\\mu$m$^3$ volume of Al$_2$SiO$_5$ in free space (stress-free boundaries)? Take the surface energy, $\\gamma$, to be equal to 200 mJ/m$^2$. The crystalline axes $a$, $b$, and $c$ are aligned with the $x$, $y$, and $z$-axes of a Cartesian lab coordinate system.\n\nThis problem can be cast as a phase field problem, where the phase field $\\varphi\\in[0,1]$ takes the value of 1 in one phase (the \"potato\"), and a value of 0 in the other (the surrounding vacuum). Thus, the total free energy can be written\n\\begin{equation}\n{\\mathcal F}=\\int \\left[f_{\\rm elastic}+\\frac{\\kappa}{2}|\\nabla\\varphi|^2+h_0f(\\varphi)\\right]\\,dV,\n\\end{equation}\nwith the integral extended over all space,\nwhere\n$f(\\varphi)$ is a (dimensionless) double-well function\n\\begin{equation}\nf(\\varphi)=\\varphi^2\\left[\\varphi-1\\right]^2,\n\\end{equation}\nand $h_0$ has the dimension of energy per unit volume. The interface width $W$ between approximately $\\varphi=0.1$ and $\\varphi=0.9$ in this model is given by $W=2\\sqrt{2\\kappa/h_0}$, while $\\gamma=\\sqrt{\\kappa h_0/18}$, $\\kappa=1.5\\gamma W$, and $h_0=12\\gamma/W$ (ignoring modification of the phase field order parameter $\\varphi$ by the elastic interactions through the interface). Use $\\kappa=3\\times10^{-9}$~J/m, and\n$h_0=2.4\\times10^{8}$~J/m$^3$. \n\nWe use a simple interpolation of the elastic constants, \n\n\\begin{equation}\nC_{ijkl}=h(\\varphi)C_{ijkl}^{\\rm potato},%+\\left[1-h(\\varphi)\\right]C_{ijkl}^{\\rm matrix},\n\\end{equation}\n\nwhere $h(\\varphi)$ is a smooth interpolation function,\n\\begin{equation}\nh(\\varphi)=\\varphi^3\\left[6\\varphi^2-15\\varphi+10\\right],\n\\end{equation}\nthat interpolates between $h(\\varphi=0)=0$ and $h(\\varphi=1)=1$.\n\nHint: find time-evolution equations for $\\varphi$ that monotonically drive the total energy to a minimum while preserving the volume. One way to do this is to set up a Cahn-Hilliard equation for $\\varphi$.\n\n(b) (Compressed potato in space) What is the equilibrium shape of a 0.0042 $\\mu$m$^3$ volume Al$_2$SiO$_5$ with uniaxial compressive stress of 500~MPa applied in the $z$-direction? Note that the strain must go to zero far from the \"potato.\"\n\n(c) (Potato in a stew) A volume of Al$_2$SiO$_5$ is embedded coherently in a matrix of tetragonal symmetry with unit cell parameters $a_m=b_m=7.6918\\;\\unicode{x212B}$ and $c_m=5.5674\\;\\unicode{x212B}$ such that $a$ and $a_m$, $b$ and $b_m$ and $c$ and $c_m$ are pairwise aligned. The elastic tensor of the matrix is given by $C_{11}=C_{22}=269.0$, $C_{12}=177.0$, $C_{13}=146.0$, $C_{33}=480.0$, $C_{44}=124.0$, and $C_{66}=192.0$, all in units of GPa.\n\nThis problem can also be cast as a phase field problem, where now the phase field $\\varphi\\in[0,1]$ takes the value of 1 in one phase (the inclusion), and a value of 0 in the other (the matrix). The total free energy is again\n\\begin{equation}\n{\\mathcal F}=\\int \\left[f_{\\rm elastic}+\\frac{\\kappa}{2}|\\nabla\\varphi|^2+h_0f(\\varphi)\\right]\\,dV,\n\\end{equation}\nwhere \n$f(\\varphi)$ is given by above.\n\nThe interpolation of the elastic constants is now, \n\n\\begin{equation}\nC_{ijkl}=h(\\varphi)C_{ijkl}^{\\rm inclusion}+\\left[1-h(\\varphi)\\right]C_{ijkl}^{\\rm matrix},\n\\end{equation}\n\nwhere again $h(\\varphi)$ is a smooth interpolation function given above.\n\nIn the elastic energy, the relevant strain is the total strain $\\epsilon_{ij}$ minus the local misfit strain $\\epsilon^0_{ij}$, so\n\n\\begin{equation}\nf_{\\rm elastic}=\\frac{1}{2}C_{ijkl}\\left(\\epsilon_{ij}-\\epsilon^0_{ij}\\right)\\left(\\epsilon_{kl}-\\epsilon^0_{kl}\\right).\n\\end{equation}\n\nWe will use Vegard's law to determine the local misfit strain, for which we just interpolate the crystallographic misfit strain tensor, $\\epsilon^T_{ij}$:\n\n\\begin{equation}\n\\epsilon^0_{ij}=h(\\varphi)\\epsilon^T_{ij},\n\\end{equation}\n\nwhere $h(\\varphi)$ is the interpolation function, and $\\epsilon^T_{ij}$ is\n\\begin{equation}\n\\epsilon^T_{ij}=\\left(\n\\begin{matrix}\n\\frac{a-a_m}{a_m} & 0 & 0\\\\\n0 & \\frac{b-b_m}{b_m} & 0\\\\\n0& 0 & \\frac{c-c_c}{c_m}\n\\end{matrix}\n\\right).\n\\end{equation}\n\nFind the equilibrium shape of an isolated inclusion with a volume of 0.0042 $\\mu$m$^3$ for $\\kappa=3\\times10^{-9}$ J/m, and $h_0=2.4\\times10^{8}$ J/m$^3$. Use as an initial condition a prolate ellipsoid with $a=c=0.155$ $\\mu$m and $b=0.042$ $\\mu$m. Because of elastic strain energy and interfacial energy within the system, you will need to increase the intial values of the phase field variable in the matrix and the precipitate (e.g., $\\varphi$ in the precipitate $\\approx$ 1.05; $\\varphi$ in the matrix $\\approx 0.05$). Note that the strain must go to zero far from the \"potato\".\n\nFor parts (a) - (c), present a rendering of the final shape as well as the lengths of the \"potato\" along the principal axes, and also track the total free energy as function of \"time\" and plot it.\n\n", "meta": {"hexsha": "ec8792204a3264320ffca67876841e8e670d41bf", "size": 11622, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "hackathons/hackathon2/problem2.ipynb", "max_stars_repo_name": "wd15/chimad-phase-field", "max_stars_repo_head_hexsha": "b8ead2ef666201b500033052d0a4efb55796c2da", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11, "max_stars_repo_stars_event_min_datetime": "2016-04-19T13:51:02.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-30T07:52:21.000Z", "max_issues_repo_path": "hackathons/hackathon2/problem2.ipynb", "max_issues_repo_name": "usnistgov/chimad-phase-field", "max_issues_repo_head_hexsha": "7f07e5ab046b917dfa32d84a68421ed94ec03a3b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 417, "max_issues_repo_issues_event_min_datetime": "2015-03-20T16:39:11.000Z", "max_issues_repo_issues_event_max_datetime": "2018-01-16T16:33:53.000Z", "max_forks_repo_path": "hackathons/hackathon2/problem2.ipynb", "max_forks_repo_name": "stvdwtt/chimad-phase-field", "max_forks_repo_head_hexsha": "cf0c0b923b7dcfd8eb5785fb778438387194920d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15, "max_forks_repo_forks_event_min_datetime": "2015-03-20T21:44:06.000Z", "max_forks_repo_forks_event_max_datetime": "2017-12-05T23:39:36.000Z", "avg_line_length": 46.119047619, "max_line_length": 751, "alphanum_fraction": 0.5745998967, "converted": true, "num_tokens": 2682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4960938294709195, "lm_q2_score": 0.14804720179063333, "lm_q1q2_score": 0.07344530327876926}}
{"text": "# Notebook contents: \n\nThis notebook contains a lecture. The code for generating plots are found at the of the notebook. Links below.\n\n- [presentation](#Session-1b:)\n- [code for plots](#Code-for-plots)\n\n# Session 11:\n## Machine learning introduction\n\n*Andreas Bjerre-Nielsen*\n\n## Taking stock\n\n*What have we learned until now?*\n- Fundamental data types, functions, containes, loops\n- Pandas: DataFrame, Series - these contain basic datatypes\n - A lot of powerful tools in methods/functions\n - E.g. groupby, join/merge\n- Scraping: API, HTML, and a lot more\n\n## Some coding advice\n\n- *How do I extract an object from my function?* \n - Print or return?\n- Solving complex problems: \n - Solve one thing at a time, start with the most essential that you can do now\n- Is joining datasets difficult? \n - Check out [the pandas documentation on merging](https://pandas.pydata.org/pandas-docs/stable/user_guide/merging.html)\n - Or [the guide available from Jake Van der Plas](https://jakevdp.github.io/PythonDataScienceHandbook/03.07-merge-and-join.html)\n\n\n```python\ndef my_fct(a):\n b = a + 1\n return (b)\n \nc = my_fct(2)\nprint(c)\n```\n\n 3\n\n\n## Agenda\n\n1. [Math and stats review](#Math-review)\n1. [Why machine learing](#Why-machine-learning)\n1. [What is machine learning](#Machine-learning-overview)\n1. Classification models\n 1. [the perceptron](#The-perceptron-model)\n 1. [beyond the perceptron](#Beyond-the-perceptron)\n\n## Math review\n\nVector: 1-d dimensional array of numbers \n\\begin{align}\\boldsymbol{x}=[x_0,x_1,x_2,..]\\end{align}\n\n
\n\nMatrix: 2-d dimensional array of numbers \n\\begin{eqnarray}\\boldsymbol{X}=[\n[&x_{00}&,x_{01}&,x_{02}&,..&],\\\\\n[&x_{10}&,x_{11}&,x_{12}&,..&],\\\\\n[&x_{20}&,x_{21}&,x_{22}&,..&],\\\\\n[&... &,... &,... &,..&]]\n\\end{eqnarray}\n\n\n## Function fitting\n*What does (supervised) machine learning do?*\n\nSuppose we have some data $y$ we want to model/predict from input $x$. \n\nThe aim is to find a function $f$ such that the distance between actual values $y$ and predicted values $f(x)$ are minimized.\n\n*What are some examples?*\n\n- Linear form: $y=x\\beta$.\n- Logistic form: $y=g(x\\beta)$\n\nwhere $x^T\\beta=\\beta_0+x_1\\beta_1+x_2\\beta_2+...+x_n\\beta_n$ (vector dot product)\n\n# Why machine learning\n\n## Value of modelling \n*Why are models useful?*\n\nModels are pursued with differens aims. Suppose we have a linear model, $y=x\\beta+\\epsilon$.\n\n- Social science:\n - They teach us something about the world.\n - We want to estimate $\\hat{\\beta}$ and distribution\n- Data science:\n - To make optimal future decisions and precise predictions, i.e. $\\hat{y}$. \n\n## Model fragility (1)\n*What is a polynomial regression?*\n\n- Fitting a curve with an *n-dimenstional polynomial*\n- Can fit any \"regular\" curve ~ Taylor Series Approximation.\n\n## Model fragility (2)\n*Suppose we build models of the size of the Danish population, how do polynomial fits perform?*\n- We estimate model with data from 1769-1975.\n\n\n```python\nf_pop1\n```\n\n## Model fragility (3)\n*Which model performs best when we extend the forecasting period from 1975 to now?*\n\n\n```python\nf_pop2\n```\n\n## Model fragility (4)\n*What happens if we extend the prediction period until 2050? See the fifth order.*\n\n\n```python\nf_pop3\n```\n\n## Model fragility (5)\n*What trade off do we face in modelling?*\n\n- Making a model that is too simple and does not capture enough of data (`underfitting`)\n- Making a model with great fit on estimation data, but poor out-of-sample prediction (`overfitting`)\n\nThe goal of machine learning is to find models that minimize these two problems simultaneously.\n\n## Learning ML\n\n- During lectures copy code for see what it does - ***listen*** to me. Write own notes.\n- After lecture > understand code details\n- Learn with your group - VERY IMPORTANT!\n\n# Machine learning overview\n\n## Machine learning outline for this course \n\nML: short for machine learning\n\n- Problems: ***supervised*** vs unsupervised\n- Linear supervised ML models \n - classification and regression\n - regularization \n - **getting hands dirty with implementing solver**\n- Fundamental concepts of ML\n - overfitting, underfitting, model validation\n - model selection and hyperparameters\n- Emphasize differences and synergies between ML and statistics\n- Brief intro of non-linear models\n\n## What is machine learning\n*Can you define machine learning, i.e. ML?*\n\n- Supervised learning\n - Models designed to infer a relationship between input and **labeled** data. \n - We define the `target` as labels in data we wish to model. \n - Example: population as a function of year. \n- Unsupervised learning\n - Find patterns and relationships from **unlabeled** data. \n - This may involve clustering, dimensionality reduction and more. \n - Not part of the course.\n\n## Why machine learning \n*How might this be useful for social scientists?*\n\nSupervised machine learning is important (elaborated in Lecture 14):\n- Improve estimation by validating models (not only theory)\n- We can generate new data (impute missing)\n- Better predictive models \n- Use in hybrid models that leverage machine learning for causal estimation \n - (e.g. causal forest, neural instrumentation)\n\n## Supervised ML problems \n*How can we categorize a supervised ML model?*\n\nSuppose we have model $y=g(X\\beta)$\n\nWe distinguish by type of the `target` variable `y`:\n- **regression**: predict a numeric value\n- **classification**: distinguish between target categories (non-numeric data)\n\n## Supervised ML problems (2)\n*Which one is classification, which one is regression?*\n\n\n```python\nf_identify_question\n```\n\n## Supervised ML problems (3)\n\n\n```python\nf_identify_answer\n```\n\n## Regression models\n*What are examples of regressions models?*\n\n- Example of targets: income, life expectancy, education length (years)\n\n*What is the underlying data of the target, $y$?*\n\n- target is `continuous` \n\n## Classification models\n*What are examples of classification models?*\n\nTarget, `y`, are categories \n- Examples of target: kind of education (linguistics, math), mode of transportation\n - sometimes known as `factor` in statistics \n- (work for `str`, `bool`, `int`, `float` which are then interpreted as categories)\n\n\n## Example of supervised ML\n*Classification or regression?*\n\nWe load the titanic data. We select variables and make dummy variables from categorical. We split into target and features. \n\nTarget is: ...?\n\n\n```python\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\n\ntitanic = sns.load_dataset('titanic')\ncols = ['survived','class', 'sex', 'sibsp', 'age', 'alone']\ntitanic_sub = pd.get_dummies(titanic[cols].dropna(), drop_first=True).astype(np.int64) \n\nX = titanic_sub.drop('survived', axis=1)\ny = titanic_sub.survived\n```\n\n## Definitions\n\nML lingo and econometric equivalents (in italic)\n\n- `feature` vector, $\\textbf{x}_i$, i.e a row of input variables\n - = explanatory *variables* in econometrics\n- `weight` vector, $\\textbf{w}$, i.e model parameters\n - = *coefficients* in econometrics where denoted $\\beta$\n- `bias` term, $w_0$, i.e. the model intercept\n - = the *constant* variable in denoted $\\beta_0$\n \n\n# The perceptron model \n\n## The articifial neuron\n\nA real neuron maps stimulus (input) to output. \n\n[Research estimates](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC5063692) there are 55–70 billion neurons in the brain.\n
\n- We take gradient descent - much simpler (often faster)\n\n## A new objective (3)\n*How does a gradient descent look?*\n\nAn algorithm that finds the direction where expected differences are largest. Attempt of satisfying first order condition (FOC).\n\n\n
\n\nSpecial routines are available for evolving under a diagonal Coulomb operator. This notebook describes how to use these built in routines and how they work.\n\n\n```python\ntry:\n import fqe\nexcept ImportError:\n !pip install fqe --quiet\n```\n\n\n```python\nfrom itertools import product\nimport fqe\nfrom fqe.hamiltonians.diagonal_coulomb import DiagonalCoulomb\n\nimport numpy as np\n\nimport openfermion as of\n\nfrom scipy.linalg import expm\n```\n\n\n```python\n#Utility function\ndef uncompress_tei(tei_mat, notation='chemistry'):\n \"\"\"\n uncompress chemist notation integrals\n\n tei_tensor[i, k, j, l] = tei_mat[(i, j), (k, l)]\n [1, 1, 2, 2] = [1, 1, 2, 2] = [1, 1, 2, 2] = [1, 1, 2, 2]\n [i, j, k, l] = [k, l, i, j] = [j, i, l, k]* = [l, k, j, i]*\n\n For real we also have swap of i <> j and k <> l\n [j, i, k, l] = [l, k, i, j] = [i, j, l, k] = [k, l, j, i]\n\n tei_mat[(i, j), (k, l)] = int dr1 int dr2 phi_i(dr1) phi_j(dr1) O(r12) phi_k(dr1) phi_l(dr1)\n\n Physics notation is the notation that is used in FQE.\n\n Args:\n tei_mat: compressed two electron integral matrix\n\n Returns:\n uncompressed 4-electron integral tensor. No antisymmetry.\n \"\"\"\n if notation not in ['chemistry', 'physics']:\n return ValueError(\"notation can be [chemistry, physics]\")\n\n norbs = int(0.5 * (np.sqrt(8 * tei_mat.shape[0] + 1) - 1))\n basis = {}\n cnt = 0\n for i, j in product(range(norbs), repeat=2):\n if i >= j:\n basis[(i, j)] = cnt\n cnt += 1\n\n tei_tensor = np.zeros((norbs, norbs, norbs, norbs))\n for i, j, k, l in product(range(norbs), repeat=4):\n if i >= j and k >= l:\n tei_tensor[i, j, k, l] = tei_mat[basis[(i, j)], basis[(k, l)]]\n tei_tensor[k, l, i, j] = tei_mat[basis[(i, j)], basis[(k, l)]]\n tei_tensor[j, i, l, k] = tei_mat[basis[(i, j)], basis[(k, l)]]\n tei_tensor[l, k, j, i] = tei_mat[basis[(i, j)], basis[(k, l)]]\n\n tei_tensor[j, i, k, l] = tei_mat[basis[(i, j)], basis[(k, l)]]\n tei_tensor[l, k, i, j] = tei_mat[basis[(i, j)], basis[(k, l)]]\n tei_tensor[i, j, l, k] = tei_mat[basis[(i, j)], basis[(k, l)]]\n tei_tensor[k, l, j, i] = tei_mat[basis[(i, j)], basis[(k, l)]]\n\n if notation == 'chemistry':\n return tei_tensor\n elif notation == 'physics':\n return np.asarray(tei_tensor.transpose(0, 2, 1, 3), order='C')\n\n return tei_tensor\n\n```\n\nThe first example we will perform is diagonal Coulomb evolution on the Hartree-Fock state. The diagonal Coulomb operator is defined as\n\n\\begin{align}\nV = \\sum_{\\alpha, \\beta \\in \\{\\uparrow, \\downarrow\\}}\\sum_{p,q} V_{pq,pq}n_{p,\\alpha}n_{q,\\beta}\n\\end{align}\n\nThe number of free parpameters are $\\mathcal{O}(N^{2})$ where $N$ is the rank of the spatial basis. The `DiagonalCoulomb` Hamiltonian takes either a generic 4-index tensor or the $N \\times N$ matrix defining $V$. If the 4-index tensor is given the $N \\times N$ matrix is constructed along with the diagonal correction. If the goal is to just evolve under $V$ it is recommended the user input the $N \\times N$ matrix directly.\n\nAll the terms in $V$ commute and thus we can evolve under $V$ exactly by counting the accumulated phase on each bitstring.\n\n\nTo start out let's define a Hartree-Fock wavefunction for 4-orbitals and 2-electrons $S_{z} =0$.\n\n\n```python\nnorbs = 4\ntedim = norbs * (norbs + 1) // 2\nif (norbs // 2) % 2 == 0:\n n_elec = norbs // 2\nelse:\n n_elec = (norbs // 2) + 1\nsz = 0\nfqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])\nfci_data = fqe_wfn.sector((n_elec, sz))\nfci_graph = fci_data.get_fcigraph()\nhf_wf = np.zeros((fci_data.lena(), fci_data.lenb()), dtype=np.complex128)\nhf_wf[0, 0] = 1 # right most bit is zero orbital.\nfqe_wfn.set_wfn(strategy='from_data',\n raw_data={(n_elec, sz): hf_wf})\nfqe_wfn.print_wfn()\n```\n\nNow we can define a random 2-electron operator $V$. To define $V$ we need a $4 \\times 4$ matrix. We will generate this matrix by making a full random two-electron integral matrix and then just take the diagonal elements\n\n\n```python\ntei_compressed = np.random.randn(tedim**2).reshape((tedim, tedim))\ntei_compressed = 0.5 * (tei_compressed + tei_compressed.T)\ntei_tensor = uncompress_tei(tei_compressed, notation='physics')\n\ndiagonal_coulomb = of.FermionOperator()\ndiagonal_coulomb_mat = np.zeros((norbs, norbs))\nfor i, j in product(range(norbs), repeat=2):\n diagonal_coulomb_mat[i, j] = tei_tensor[i, j, i, j]\n for sigma, tau in product(range(2), repeat=2):\n diagonal_coulomb += of.FermionOperator(\n ((2 * i + sigma, 1), (2 * i + sigma, 0), (2 * j + tau, 1),\n (2 * j + tau, 0)), coefficient=diagonal_coulomb_mat[i, j])\n\ndc_ham = DiagonalCoulomb(diagonal_coulomb_mat)\n\n```\n\nEvolution under $V$ can be computed by looking at each bitstring, seeing if $n_{p\\alpha}n_{q\\beta}$ is non-zero and then phasing that string by $V_{pq}$. For the Hartree-Fock state we can easily calculate this phase accumulation. The alpha and beta bitstrings are \"0001\" and \"0001\". \n\n\n```python\nalpha_occs = [list(range(fci_graph.nalpha()))]\nbeta_occs = [list(range(fci_graph.nbeta()))]\noccs = alpha_occs[0] + beta_occs[0]\ndiag_ele = 0.\nfor ind in occs:\n for jnd in occs:\n diag_ele += diagonal_coulomb_mat[ind, jnd]\nevolved_phase = np.exp(-1j * diag_ele)\nprint(evolved_phase)\n\n# evolve FQE wavefunction\nevolved_hf_wfn = fqe_wfn.time_evolve(1, dc_ham)\n\n# check they the accumulated phase is equivalent!\nassert np.isclose(evolved_hf_wfn.get_coeff((n_elec, sz))[0, 0], evolved_phase)\n\n```\n\nWe can now try this out for more than 2 electrons. Let's reinitialize a wavefunction on 6-orbitals with 4-electrons $S_{z} = 0$ to a random state.\n\n\n```python\nnorbs = 6\ntedim = norbs * (norbs + 1) // 2\nif (norbs // 2) % 2 == 0:\n n_elec = norbs // 2\nelse:\n n_elec = (norbs // 2) + 1\nsz = 0\nfqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])\nfqe_wfn.set_wfn(strategy='random')\ninital_coeffs = fqe_wfn.get_coeff((n_elec, sz)).copy()\nprint(\"Random initial wavefunction\")\nfqe_wfn.print_wfn()\n```\n\nWe need to build our Diagoanl Coulomb operator For this bigger system.\n\n\n```python\ntei_compressed = np.random.randn(tedim**2).reshape((tedim, tedim))\ntei_compressed = 0.5 * (tei_compressed + tei_compressed.T)\ntei_tensor = uncompress_tei(tei_compressed, notation='physics')\n\ndiagonal_coulomb = of.FermionOperator()\ndiagonal_coulomb_mat = np.zeros((norbs, norbs))\nfor i, j in product(range(norbs), repeat=2):\n diagonal_coulomb_mat[i, j] = tei_tensor[i, j, i, j]\n for sigma, tau in product(range(2), repeat=2):\n diagonal_coulomb += of.FermionOperator(\n ((2 * i + sigma, 1), (2 * i + sigma, 0), (2 * j + tau, 1),\n (2 * j + tau, 0)), coefficient=diagonal_coulomb_mat[i, j])\n\ndc_ham = DiagonalCoulomb(diagonal_coulomb_mat)\n\n```\n\nNow we can convert our wavefunction to a cirq wavefunction, evolve under the diagonal_coulomb operator we constructed and then compare the outputs.\n\n\n```python\ncirq_wfn = fqe.to_cirq(fqe_wfn).reshape((-1, 1))\nfinal_cirq_wfn = expm(-1j * of.get_sparse_operator(diagonal_coulomb)) @ cirq_wfn\n# recover a fqe wavefunction\nfrom_cirq_wfn = fqe.from_cirq(final_cirq_wfn.flatten(), 1.0E-8)\n\n```\n\n\n```python\nfqe_wfn = fqe_wfn.time_evolve(1, dc_ham)\nprint(\"Evolved wavefunction\")\nfqe_wfn.print_wfn()\n```\n\n\n```python\nprint(\"From Cirq Evolution\")\nfrom_cirq_wfn.print_wfn()\nassert np.allclose(from_cirq_wfn.get_coeff((n_elec, sz)),\n fqe_wfn.get_coeff((n_elec, sz)))\nprint(\"Wavefunctions are equivalent\")\n```\n\nFinally, we can compare against evolving each term of $V$ individually.\n\n\n```python\nfqe_wfn = fqe.Wavefunction([[n_elec, sz, norbs]])\nfqe_wfn.set_wfn(strategy='from_data',\n raw_data={(n_elec, sz): inital_coeffs})\nfor term, coeff in diagonal_coulomb.terms.items():\n op = of.FermionOperator(term, coefficient=coeff)\n fqe_wfn = fqe_wfn.time_evolve(1, op)\n\nassert np.allclose(from_cirq_wfn.get_coeff((n_elec, sz)),\n fqe_wfn.get_coeff((n_elec, sz)))\nprint(\"Individual term evolution is equivalent\")\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "3b477d6116596f517905bb40bea0d9144078f881", "size": 14367, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/diagonal_coulomb_evolution.ipynb", "max_stars_repo_name": "rmlarose/OpenFermion-FQE", "max_stars_repo_head_hexsha": "54489126725fe3bb83218b6fde9d44f6cf130359", "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/diagonal_coulomb_evolution.ipynb", "max_issues_repo_name": "rmlarose/OpenFermion-FQE", "max_issues_repo_head_hexsha": "54489126725fe3bb83218b6fde9d44f6cf130359", "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/diagonal_coulomb_evolution.ipynb", "max_forks_repo_name": "rmlarose/OpenFermion-FQE", "max_forks_repo_head_hexsha": "54489126725fe3bb83218b6fde9d44f6cf130359", "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.3866995074, "max_line_length": 440, "alphanum_fraction": 0.5645576669, "converted": true, "num_tokens": 3030, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.4263215925474903, "lm_q2_score": 0.16885694377651225, "lm_q1q2_score": 0.07198736118350474}}
{"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\n\n\n\n\n\n\n\n\n\n\n```python\nfrom sympy import init_printing, Matrix, symbols, eye\nfrom warnings import filterwarnings\n```\n\n\n```python\ninit_printing(use_latex = 'mathjax')\nfilterwarnings('ignore')\n```\n\n\n```python\nlamda = symbols('lamda') # Note that lambda is a reserved word in python, so we use lamda (without the b)\n```\n\n# Eigenvalues and eigenvectors\n\n## What are eigenvectors?\n\n* A Matrix is a mathematical object that acts on a (column) vector, resulting in a new vector, i.e. A**x**=**b**\n* An eigenvector is the resulting vector that is parallel to **x** (some multiple of **x**)\n$$ {A}\\underline{x}=\\lambda \\underline{x} $$\n\n* The eigenvectors with an eigenvalue of zero are the vectors in the nullspace\n* If A is singular (takes some non-zero vector into 0) then λ=0\n\n## What are the eigenvectors and eigenvalues for projection matrices?\n\n* A projection matrix P projects some vector (**b**) onto a subspace (in 3-space we are talking about a plane through the origin)\n* P**b** is not in the same direction as **b**\n* A vector **x** that is already in the subspace will result in P**x**=**x**, so λ=1\n* Another good **x** would be one perpendicular to the subspace, i.e. P**x**=0**x**, so λ=0\n\n## What are the eigenvectors and eigenvalues for permutation matrices?\n\n* A permutation matrix such as the one below changes the order of the elements in a (column) vector\n$$ \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix} $$\n* A good example of a vector that would remain in the same direction after multiplication by the permutation matrix above would the following vector\n$$ \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} $$\n* The eigenvalue would just be λ=1\n* The next (eigen)vector would also work\n$$ \\begin{bmatrix} -1 \\\\ 1 \\end{bmatrix} $$\n* It would have an eigenvalue of λ=-1\n\n## The trace and the determinant\n\n* The trace is the sum of the values down the main diagonal of a square matrix\n* Note how this is the same as the sum of the eigenvalues (look at the permutation matrix above and its eigenvalues)\n* The determinant of A is the product of the eigenvalues\n\n## How to solve A**x**=λ**x**\n\n$$ A\\underline { x } =\\lambda \\underline { x } \\\\ \\left( A-\\lambda I \\right) \\underline { x } =\\underline { 0 } $$\n\n* The only solution to this equation is for A-λI to be singular and therefor have a determinant of zero\n$$ \\left|{A}-\\lambda{I}\\right|=0 $$\n\n* This is called the characteristic (or eigenvalue) equation\n* There will be *n* λ's for a *n*×*n* matrix(some of which may be of equal value) \n\n\n```python\nA = Matrix([[3, 1], [1, 3]])\nI = eye(2)\nA, I # Printing A and the 2-by-2 identity matrix to the screen\n```\n\n\n\n\n$$\\begin{pmatrix}\\left[\\begin{matrix}3 & 1\\\\1 & 3\\end{matrix}\\right], & \\left[\\begin{matrix}1 & 0\\\\0 & 1\\end{matrix}\\right]\\end{pmatrix}$$\n\n\n\n\n```python\n(A - lamda * I) # Printing A minus lambda times the identity matrix to the screen\n```\n\n\n\n\n$$\\left[\\begin{matrix}- \\lambda + 3 & 1\\\\1 & - \\lambda + 3\\end{matrix}\\right]$$\n\n\n\n* This will have the following determinant\n\n\n```python\n(A - lamda * I).det()\n```\n\n\n\n\n$$\\lambda^{2} - 6 \\lambda + 8$$\n\n\n\n* For this 2×2 matrix the absolute value of the -6 is the trace of A and the 8 is the determinant of A\n\n\n```python\n((A - lamda * I).det()).factor()\n```\n\n\n\n\n$$\\left(\\lambda - 4\\right) \\left(\\lambda - 2\\right)$$\n\n\n\n* I now have two eigenvalues of 2 and 4\n\n* In python we could also use the .*eigenvals()* statement\n\n\n```python\nA.eigenvals() # There is one value of 2 and one value of 4\n```\n\n\n\n\n$$\\begin{Bmatrix}2 : 1, & 4 : 1\\end{Bmatrix}$$\n\n\n\n* The eigenvectors are calculated by substituting the two values of λ into the original equation\n$$ \\left( {A}-\\lambda{I} \\right)\\underline{x}=\\underline{0} $$\n\n\n```python\nA.eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}2, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}-1\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}4, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}1\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n* The results above is interpreted as follows\n * The first eigenvalue has one eigenvector and the second eigenvalue also has a single eigenvector\n\n* Note the similarity between the eigenvectors of the two examples above\n* It is easy to see that adding a constant multiple of the identity matrix to another matrix (above we added 3I to the initial matrix) doesn't change the eigenvectors; it does add that constant to the eigenvalues though (we went from -1 and 1 to 2 and 4)\n$$ A\\underline { x } =\\lambda \\underline { x } \\\\ \\therefore \\quad \\left( A+cI \\right) \\underline { x } =\\left( \\lambda +c \\right) \\underline { x } $$\n\n* If we add another matrix to A (not a constant multiple of I) or even multiply them, then the influence on the original eigenvalues and eigenvectors of A is NOT so predictable (as above)\n\n## The eigenvalues and eigenvectors of a rotation matrix\n\n* Consider this rotation matrix that rotates a vector by 90o (it is orthogonal)\n * Think about it, though: what vector can come out parallel to itself after a 90o rotation?\n\n\n```python\nQ = Matrix([[0, -1], [1, 0]])\nQ\n```\n\n\n\n\n$$\\left[\\begin{matrix}0 & -1\\\\1 & 0\\end{matrix}\\right]$$\n\n\n\n* From the trace and determinant above we know that we will have the following equation\n$$ {\\lambda}^{2}-{0}{\\lambda}+{1}={0} \\\\ {\\lambda}^{2}=-{1} $$\n\n\n```python\nQ.eigenvals()\n```\n\n\n\n\n$$\\begin{Bmatrix}- i : 1, & i : 1\\end{Bmatrix}$$\n\n\n\n\n```python\nQ.eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}- i, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}- i\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}i, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}i\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n* Note how the eigenvalues are complex conjugates\n* Symmetric matrices will only have real eigenvalues\n* An *anti*-symmetric matrix (where the transpose is the original matrix times the scalar -1, as our example above) will only have complex eigenvalues\n* Matrices in between can have a mix of these\n\n## Eigenvalues and eigenvectors of an upper triangular matrix\n\n* Compute the eigenvalues and eigenvectors of the following matrix (note it is upper triangular)\n\n\n```python\nA = Matrix([[3, 1], [0, 3]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & 1\\\\0 & 3\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.eigenvals()\n```\n\n\n\n\n$$\\begin{Bmatrix}3 : 2\\end{Bmatrix}$$\n\n\n\n* We have two eigenvalues, both equal to 3\n\n\n```python\nA.eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}3, & 2, & \\begin{bmatrix}\\left[\\begin{matrix}1\\\\0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n* This is a degenerate matrix; it does not have independent eigenvectors\n\n* Look at this upper triangular matrix\n\n\n```python\nA = Matrix([[3, 1, 1], [0, 3, 4], [0, 0, 3]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}3 & 1 & 1\\\\0 & 3 & 4\\\\0 & 0 & 3\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.eigenvals()\n```\n\n\n\n\n$$\\begin{Bmatrix}3 : 3\\end{Bmatrix}$$\n\n\n\n\n```python\nA.eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}3, & 3, & \\begin{bmatrix}\\left[\\begin{matrix}1\\\\0\\\\0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n## Example problems\n\n### Example problem 1\n\n* Find the eigenvalues and eigenvectors of the square of the following matrix as well as the inverse of the matrix minus the identity matrix\n$$ {A}=\\begin{bmatrix} 1 & 2 & 3 \\\\ 0 & 1 & -2 \\\\ 0 & 1 & 4 \\end{bmatrix} $$\n\n#### Solution\n\n* Notice the following\n$$ A\\underline { x } =\\lambda \\underline { x } \\\\ { A }^{ 2 }\\underline { x } =A\\left( A\\underline { x } \\right) =A\\left( \\lambda \\underline { x } \\right) =\\lambda \\left( A\\underline { x } \\right) ={ \\lambda }^{ 2 }\\underline { x } $$\n* Once we know the eigenvalues for A we than simply square them to get the eigenvalues of the matrix squared\n\n* Similarly for the inverse of the matrix we have the following (for a non-zero λ, which is fine as A must be invertible for this problem)\n$$ { A }^{ -1 }\\underline { x } ={ A }^{ -1 }\\frac { A\\underline { x } }{ \\lambda } ={ A }^{ -1 }A\\frac { 1 }{ \\lambda } \\underline { x } =\\frac { 1 }{ \\lambda } \\underline { x} $$\n\n\n```python\nA = Matrix([[1, 2, 3], [0, 1, -2], [0, 1, 4]])\nA\n```\n\n\n\n\n$$\\left[\\begin{matrix}1 & 2 & 3\\\\0 & 1 & -2\\\\0 & 1 & 4\\end{matrix}\\right]$$\n\n\n\n\n```python\nA.eigenvals()\n```\n\n\n\n\n$$\\begin{Bmatrix}1 : 1, & 2 : 1, & 3 : 1\\end{Bmatrix}$$\n\n\n\n\n```python\nA.eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}1, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}1\\\\0\\\\0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}2, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-2\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}3, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}\\frac{1}{2}\\\\-1\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n* From this it is clear that the eigenvalues of A2 will be 1, 4, and 9 and for A-1 would be a 1, a half and a third\n\n\n```python\n(A ** 2).eigenvals()\n```\n\n\n\n\n$$\\begin{Bmatrix}1 : 1, & 4 : 1, & 9 : 1\\end{Bmatrix}$$\n\n\n\n\n```python\n(A.inv()).eigenvals()\n```\n\n\n\n\n$$\\begin{Bmatrix}\\frac{1}{3} : 1, & \\frac{1}{2} : 1, & 1 : 1\\end{Bmatrix}$$\n\n\n\n* The eigenvectors will be as follows (exactly the same)\n\n\n```python\n(A ** 2).eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}1, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}1\\\\0\\\\0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}4, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-2\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}9, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}\\frac{1}{2}\\\\-1\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n\n```python\n(A.inv()).eigenvects()\n```\n\n\n\n\n$$\\begin{bmatrix}\\begin{pmatrix}\\frac{1}{3}, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}\\frac{1}{2}\\\\-1\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}\\frac{1}{2}, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}-1\\\\-2\\\\1\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}, & \\begin{pmatrix}1, & 1, & \\begin{bmatrix}\\left[\\begin{matrix}1\\\\0\\\\0\\end{matrix}\\right]\\end{bmatrix}\\end{pmatrix}\\end{bmatrix}$$\n\n\n\n\n```python\n\n```\n", "meta": {"hexsha": "0a6d2e4098bb5f12470b6baecdfb86a4ebdd485d", "size": 27036, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Mathematics/Linear Algebra/0.0 MIT-18.06 - Jupyter/Lecture_21_Eigenvalues_and_eigenvectors.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_21_Eigenvalues_and_eigenvectors.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_21_Eigenvalues_and_eigenvectors.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": 26.2740524781, "max_line_length": 459, "alphanum_fraction": 0.4724441485, "converted": true, "num_tokens": 4021, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3522017684487511, "lm_q2_score": 0.20434190235957034, "lm_q1q2_score": 0.0719695793792227}}
{"text": "\n View on QuantumAI\n \n \n Run in Google Colab\n \n \n View source on GitHub\n \n \n Download notebook\n \nModelos de inventarios
\n\n
\n\nThis notebook provides an introduction to the Quantum Approximate Optimization Algorithm (QAOA) using the Cirq. The presentation mostly follows [Farhi et al.](https://arxiv.org/abs/1411.4028). We will show how to construct the QAOA circuit and use it to solve some simple problems.\n\n\n```\n# install cirq\n!pip install cirq==0.5 --quiet\n```\n\nTo verify that Cirq is installed in your environment, try to `import cirq` and print out a diagram of the Bristlecone device.\n\n\n```\nimport cirq\nimport numpy as np\nimport sympy\nimport matplotlib.pyplot as plt\n\nprint(cirq.google.Bristlecone)\n```\n\n (0, 5)────(0, 6)\n │ │\n │ │\n (1, 4)───(1, 5)────(1, 6)────(1, 7)\n │ │ │ │\n │ │ │ │\n (2, 3)───(2, 4)───(2, 5)────(2, 6)────(2, 7)───(2, 8)\n │ │ │ │ │ │\n │ │ │ │ │ │\n (3, 2)───(3, 3)───(3, 4)───(3, 5)────(3, 6)────(3, 7)───(3, 8)───(3, 9)\n │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │\n (4, 1)───(4, 2)───(4, 3)───(4, 4)───(4, 5)────(4, 6)────(4, 7)───(4, 8)───(4, 9)───(4, 10)\n │ │ │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │ │ │\n (5, 0)───(5, 1)───(5, 2)───(5, 3)───(5, 4)───(5, 5)────(5, 6)────(5, 7)───(5, 8)───(5, 9)───(5, 10)───(5, 11)\n │ │ │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │ │ │\n (6, 1)───(6, 2)───(6, 3)───(6, 4)───(6, 5)────(6, 6)────(6, 7)───(6, 8)───(6, 9)───(6, 10)\n │ │ │ │ │ │ │ │\n │ │ │ │ │ │ │ │\n (7, 2)───(7, 3)───(7, 4)───(7, 5)────(7, 6)────(7, 7)───(7, 8)───(7, 9)\n │ │ │ │ │ │\n │ │ │ │ │ │\n (8, 3)───(8, 4)───(8, 5)────(8, 6)────(8, 7)───(8, 8)\n │ │ │ │\n │ │ │ │\n (9, 4)───(9, 5)────(9, 6)────(9, 7)\n │ │\n │ │\n (10, 5)───(10, 6)\n\n\n### Description of QAOA\n\nLet's start out with a description of the QAOA algorithm. We'll discuss the structure of the problem it tries to solve and the quantum circuit we need to build to implement it.\n\nSuppose you have a function $C(z)$ that depends on a collection of variables $z = z_1,z_2,\\ldots, z_n$, where each $z_j$ can be equal to either $+1$ or $-1$ (the important thing here is that each $z_j$ has two possible values, and by convention we choose those values to be $\\pm 1$). The QAOA is a general-purpose algorithm whose goal is to produce an assignment of the $z_j$ that gives a relatively low value of $C(z)$. It's not guaranteed to give the lowest possible value of $C(z)$---hence the name \"Approximate\"---except in a particular limit which we will discuss.\n\nThe QAOA algorithm acts on $n$ qubits. As you might guess, each qubit represents one of the variables in our function, and the $2^n$ states of the computational basis correspond to the $2^n$ possible assignments of the $z$ variables. To be more specific, let's agree that the value of $z_j$ corresponds to the measurement outcome of the Pauli-$Z$ operator on the $j$th qubit. There is a potential confusion here because the state $| 0 \\rangle$ corresponds to $z = +1$, while the state $| 1\\rangle$ corresponds to $z=-1$. This is unfortunate, but is something that we'll just have to deal with.\n\nThe QAOA algorithm is fairly simple to explain, though the reasons behind why it works are not obvious at first glance. As usual, we begin with all of our qubits initialized in the $|0\\rangle$ state. The first step is to act with $H^{\\otimes n}$, the Hadamard operator on each qubit. This prepares an equal superposition of all bitstrings, i.e., an equal superposition of all possible $z$ assignments:\n$$\nH^{\\otimes n} |0^n\\rangle =\\frac{1}{2^{n/2}} \\sum_{x \\in \\{0,1\\}^n} |x\\rangle.\n$$\nThis should be thought of as the \"real\" initial state of the algorithm. The point of the remaining steps is to affect the amplitudes so that those with small $C(z)$ values grow while those with large $C(z)$ values shrink. Then at the end when we measure the qubits we'll be more likely to find a bitstring with a small value of $C(z)$.\n\nThe meat of the algorithm relies on the following unitary operator:\n$$\nU(\\gamma,C) = e^{i\\pi \\gamma C(Z)/2}.\n$$\nThis operator deserves some explanation. First, $\\gamma$ is a paramter which we will later treat as a variational parameter, adjusting its value to produce the best possible result. $C$ here is the function we are trying to minimize, and the notation $C(Z)$ is supposed to tell you to plug in the Pauli-$Z$ operator for each qubit in place of the argument $z$. For example, if \n$$\nC(z) = 3z_1 z_2 - z_2z_3 + z_4\n$$\nthen\n$$\nC(Z) = 3Z_1 Z_2 - Z_2Z_3 + Z_4.\n$$\nIt looks like I didn't do much, but the point here is that $C(z)$ is a number while $C(Z)$ is a matrix. That matrix is diagonal in the computational basis, and those diagonal entries represent all the possible values of $C(z)$.\n\nAfter acting with $H^{\\otimes n}$, we act with $U(C,\\gamma)$. The result is still a sum over all possible bit-strings, but now the coefficients are complex phases which depend on $C$. At this point there is still an equal probability to measure any particular string, though, because Born's rule only depends on the square of the amplitude. So the algorithm is not done yet. Below we will have to figure out how to implement $U(\\gamma, C)$ in Cirq so that we can perform this step in the algorithm.\n\nThe next step of the algorithm is to act with the unitary operator\n$$\nU(\\beta,B) = e^{i\\pi\\beta B/2},~~~ B = \\sum_{j=1}^n X_j,\n$$\nwhere $\\beta$ is another variational parameter. Since the Pauli-$X$ operators on each qubit commute with each other, we can alternatively write this as\n$$\nU(\\beta, B) = \\prod_{j=1}^n e^{i\\pi\\beta X_j/2}.\n$$\nSo this is just a rotation of each qubit around the $X$-axis on the Bloch sphere by an amount determined by $\\beta$. This operation is _not_ diagonal in the computational basis, and the resulting state will not be an equal superposition over all bitstrings. So after this step there will be constructive and destructive interference, which hopefully leads to enhancement of states corresponding to small values of $C$. This $U(\\beta, B)$ is sometimes called a \"mixing\" operation. Note that, up to an inconsequential global phase, we can also write\n$$\nU(\\beta, B) = \\prod_{j=1}^n X_j^{\\beta}.\n$$\n\nThe total circuit consists of repeating the previous two steps a total of $p\\geq 1$ times, where the choice of $p$ is up to you. The parameters $\\gamma$ and $\\beta$ can be chosen independently at each step. So at the conclusion of the circuit, the state of the qubits is\n$$\n|\\gamma,\\beta\\rangle = U(\\beta_p,B)U(\\gamma_p,C)\\cdots U(\\beta_1,B)U(\\gamma_1,C)H^{\\otimes n}|0^n\\rangle.\n$$\nIf we choose $\\gamma$ and $\\beta$ so that the expectation value\n$$\nF(\\gamma,\\beta) = \\langle \\gamma,\\beta|C(Z)|\\gamma,\\beta\\rangle\n$$\nis minimized, then measuring the state $|\\gamma,\\beta\\rangle$ in the computational basis gives us a good candidate bitstring for the minimum of $C(z)$. That's the whole thing!\n\nIn summary we have to perform the following tasks in order to implement the QAOA:\n\n\n1. Figure out out to perform the $U(\\gamma, C)$ operation in Cirq for our choice of $C$.\n2. Create a quantum circuit alternating $U(\\gamma, C)$ and $U(\\beta, B)$ operations as many times as desired. \n3. Find the optimal value of the variational parameters in our circuit.\n4. Measure the output of our circuit.\n\n### Toy problem: ground state of Ising model\n\nThe Ising Model defines the energy function\n$$\nE = -\\sum_{\\langle i,j \\rangle} Z_i Z_j - \\sum_i h_i Z_i,\n$$\nwhere the notation $\\langle i,j\\rangle$ means a sum over all nearest-neighbor pairs. The picture here is that the qubits live on the vertices of a graph, and the edges of the graph define which qubits are neighbors. We'll just take out graph to be a rectangular lattice with some number of rows and some number of columns. The numbers $h_i$ have the physical interpretation of an external magnetic field.\n\nWe are interested in finding a low-lying state of the Ising Model, by which I mean a state that has a relatively low amount of energy. This is a difficult problem in general. The pairwise interaction terms would tell you that neighboring qubits should be in the same state to lower the energy, while the magnetic field terms tell you that a given qubit wants to point \"in the same direction\" as its local field, and the strength of that preference depends on the magnitude of the field. These two different kinds of pressure are not always in agreement!\n\nThis type of problem is a perfect candidate for the QAOA, where we use the energy $E$ as our cost function $C$.\n\n### ZZ Gate\n\nThe first thing we need to do is create the operation $U(\\gamma, C)$, where $C$ is equal to the Ising Model energy function. The first thing to note is that, since all of the terms in the energy commute, we can decompose this operation as\n$$\nU(\\gamma, C) = \\prod_{\\langle i,j\\rangle}e^{-i\\pi\\gamma Z_iZ_j/2} \\prod_i e^{-i\\pi \\gamma h_i Z_i/2}.\n$$\nThis requires that we have the two-qubit gate $\\exp(-i\\pi\\gamma ZZ/2)$ at our disposal. In matrix form, this is\n$$\n\\begin{align}\n\\exp(-i \\pi\\gamma Z\\otimes Z/2) = \\begin{bmatrix}\ne^{-i\\pi \\gamma/2} & 0 &0&0\\\\\n0 & e^{i\\pi \\gamma/2} &0&0\\\\\n0&0& e^{i\\pi \\gamma/2} &0 \\\\\n0&0 & 0 & e^{-i\\pi \\gamma/2}\n\\end{bmatrix}\n\\end{align}\n$$\nAs of version 0.5.0, Cirq has a built-in gate `cirq.ZZ` which is equivalent to this once you account for a global phase:\n\n\n```\na = cirq.NamedQubit(\"a\")\nb = cirq.NamedQubit(\"b\")\ngamma = 0.3 # Put your own value here.\ncircuit = cirq.Circuit.from_ops(cirq.ZZ(a,b)**gamma)\nprint(circuit)\ncirq.unitary(circuit).round(2)\n```\n\n a: ───ZZ───────\n │\n b: ───ZZ^0.3───\n\n\n\n\n\n array([[1. +0.j , 0. +0.j , 0. +0.j , 0. +0.j ],\n [0. +0.j , 0.59+0.81j, 0. +0.j , 0. +0.j ],\n [0. +0.j , 0. +0.j , 0.59+0.81j, 0. +0.j ],\n [0. +0.j , 0. +0.j , 0. +0.j , 1. +0.j ]])\n\n\n\nWe should also check that the matrix is what we expect:\n\n\n```\ntest_matrix = np.array([[np.exp(-1j*np.pi*gamma/2),0, 0, 0],\n [0, np.exp(1j*np.pi*gamma/2), 0, 0],\n [0, 0, np.exp(1j*np.pi*gamma/2), 0],\n [0, 0, 0,np.exp(-1j*np.pi*gamma/2)]])\ncirq.testing.assert_allclose_up_to_global_phase(test_matrix, cirq.unitary(circuit), atol=1e-5)\n```\n\n### Z Gate\n\nThe magnetic field terms can be handled in a similar way. The single-qubit unitary\n$$\n\\exp(-i\\pi \\gamma hZ/2) = \\begin{bmatrix}\ne^{-i\\pi \\gamma h/2} & 0 \\\\\n0 & e^{i\\pi \\gamma h/2}\n\\end{bmatrix}\n$$\nis equivalent up to global phase to `cirq.Z**(h*gamma)`:\n\n\n```\na = cirq.NamedQubit(\"a\")\ngamma = 0.3 # Put your own value here.\nh = 1.3 # Put your own value here.\ncircuit = cirq.Circuit.from_ops(cirq.Z(a)**(gamma*h))\nprint(circuit)\nprint(cirq.unitary(circuit).round(2))\n\ntest_matrix = np.array([[np.exp(-1j*np.pi*gamma*h/2),0],\n [0, np.exp(1j*np.pi*gamma*h/2)]])\ncirq.testing.assert_allclose_up_to_global_phase(test_matrix, cirq.unitary(circuit), atol=1e-5)\n```\n\n a: ───Z^0.39───\n [[1. +0.j 0. +0.j ]\n [0. +0.j 0.34+0.94j]]\n\n\n### Exercise: More general two-qubit gate\n\nThe Ising Model is particularly simple because the nearest-neighbor interaction $Z_i Z_j$ is already given in terms of a product of Pauli matrices. But suppose instead I told you that the cost function was a sum of terms that looked like\n$$\nC(z_i,z_j) = \\begin{cases}\nc_{00} \\text{ if } z_i =1,~z_j=1,\\\\\nc_{01} \\text{ if } z_i =1,~z_j=-1,\\\\\nc_{10} \\text{ if } z_i =-1,~z_j=1,\\\\\nc_{11} \\text{ if } z_i =-1,~z_j=-1.\n\\end{cases}\n$$\nFor some numbers $c_{ab}$. How would you make the analogous two-qubit gate for this case?\n\nYou can either make a custom gate from scratch, or build a solution from the standard elementary gates.\n\n### Create Circuit\n\nUsing the `cirq.ZZ` gate we can now create the QAOA circuit. We're going to focus on the Ising Model an a rectangular lattice with an arbitrary number of rows and columns. Here are some things to think about:\n\n1. `cirq.GridQubit`s are natural because our qubits actually do live on a grid. Cirq does not care what kind of qubit you make, though.\n2. It's a good idea to define separate functions to place the C and B layers for the circuit. Really these should be generators that yield the required gates.\n3. You might consider wrapping everything inside a class. We won't do that here, but if you want to play around with different numbers of rows/columns or different numbers of B/C layers it can be convenient.\n\nFirst we'll define the basic paramters of our model and the generators for the different layers:\n\n\n\n```\nn_cols = 3\nn_rows = 3\nh = 0.5*np.ones((n_rows,n_cols))\n\n# Arranging the qubits in a list-of-lists like this makes them easy to refer to later.\nqubits = [[cirq.GridQubit(i,j) for j in range(n_cols)] for i in range(n_rows)]\n\n\ndef beta_layer(beta):\n \"\"\"Generator for U(beta, B) layer (mixing layer) of QAOA\"\"\"\n for row in qubits:\n for qubit in row:\n yield cirq.X(qubit)**beta\n \ndef gamma_layer(gamma, h):\n \"\"\"Generator for U(gamma, C) layer of QAOA\n\n Args:\n gamma: Float variational parameter for the circuit\n h: Array of floats of external magnetic field values\n \"\"\"\n for i in range(n_rows):\n for j in range(n_cols):\n if i < n_rows-1:\n yield cirq.ZZ(qubits[i][j], qubits[i+1][j])**gamma\n if j < n_cols-1:\n yield cirq.ZZ(qubits[i][j], qubits[i][j+1])**gamma\n yield cirq.Z(qubits[i][j])**(gamma*h[i,j])\n```\n\nLet's test these functions by constructing the circuit. Try making a circuit with different numbers of layers. How would you automatically make a circuit with a specified number of layers? Make sure the parameters of these layers are distinct `sympy.Symbol`s for later optimization. Print the circuit to see that it's doing what you want it to do.\n\n\n```\nqaoa = cirq.Circuit()\nqaoa.append(cirq.H.on_each(*[q for row in qubits for q in row]))\n# YOUR CODE HERE\nprint(qaoa)\n```\n\n (0, 0): ───H───\n \n (0, 1): ───H───\n \n (0, 2): ───H───\n \n (1, 0): ───H───\n \n (1, 1): ───H───\n \n (1, 2): ───H───\n \n (2, 0): ───H───\n \n (2, 1): ───H───\n \n (2, 2): ───H───\n\n\n#### Solution\n\nWe'll just illustrate the solution for a single $C$ layer and a single $B$ layer.\n\n\n```\nqaoa = cirq.Circuit()\ngamma = sympy.Symbol('g')\nbeta = sympy.Symbol('b')\nqaoa.append(cirq.H.on_each(*[q for row in qubits for q in row]))\nqaoa.append(gamma_layer(gamma,h))\nqaoa.append(beta_layer(beta))\nprint(qaoa)\n```\n\n ┌──────────────────┐ ┌──────────────────┐\n (0, 0): ───H───ZZ─────ZZ─────Z^(0.5*g)───X^b────────────────────────────────────────────────────────────────────────────────────────────\n │ │\n (0, 1): ───H───┼──────ZZ^g───ZZ──────────ZZ──────Z^(0.5*g)─────────────X^b──────────────────────────────────────────────────────────────\n │ │ │\n (0, 2): ───H───┼─────────────┼───────────ZZ^g────ZZ────────────────────Z^(0.5*g)────X^b─────────────────────────────────────────────────\n │ │ │\n (1, 0): ───H───ZZ^g───ZZ─────┼───────────ZZ──────┼────────Z^(0.5*g)────X^b──────────────────────────────────────────────────────────────\n │ │ │ │\n (1, 1): ───H──────────┼──────ZZ^g────────ZZ^g────┼────────ZZ───────────ZZ───────────Z^(0.5*g)─────────────X^b───────────────────────────\n │ │ │ │\n (1, 2): ───H──────────┼──────────────────────────ZZ^g─────┼────────────ZZ^g─────────ZZ────────────────────Z^(0.5*g)───X^b───────────────\n │ │ │\n (2, 0): ───H──────────ZZ^g────────────────────────────────┼────────────ZZ───────────┼────────Z^(0.5*g)────X^b───────────────────────────\n │ │ │\n (2, 1): ───H──────────────────────────────────────────────ZZ^g─────────ZZ^g─────────┼─────────────────────ZZ──────────Z^(0.5*g)───X^b───\n │ │\n (2, 2): ───H────────────────────────────────────────────────────────────────────────ZZ^g──────────────────ZZ^g────────Z^(0.5*g)───X^b───\n └──────────────────┘ └──────────────────┘\n\n\n### Define Expectation Value\n\nTo train the QAOA circuit---that is, find the optimal values of the paramters---we're going to need to be able to compute the expectation value of the Ising Model energy. We'll do this within Cirq by defining an energy function. We'll divide the total energy by the number of qubits to keep the numbers under control, basically because we expect the energy to scale with the size of the system.\n\nIf we were using real hardware, the only way to compute the expectation value of the energy would be to estimate it by sampling. Using the simulator we can alternatively compute the wavefunction and then get calculate the expectation value from that. Not only does this save us from having to worry about statistical error, it also tends to be faster that simulating the sampling process.\n\n\n```\ndef energy_from_wavefunction(wf, h):\n \"\"\"Computes the energy-per-site of the Ising Model directly from the\n a given wavefunction. \n\n Args:\n wf: Array of size 2**(n_rows*n_cols) specifying the wavefunction.\n h: Array of shape (n_rows, n_cols) giving the magnetic field values.\n\n Returns:\n energy: Float equal to the expectation value of the energy per site \n \"\"\"\n\n n_sites = n_rows*n_cols\n\n # Z is an array of shape (n_sites, 2**n_sites). Each row consists of the \n # 2**n_sites non-zero entries in the operator that is the Pauli-Z matrix on\n # one of the qubits times the identites on the other qubits. The\n # (i*n_cols + j)th row corresponds to qubit (i,j).\n Z = np.array([(-1)**(np.arange(2**n_sites) >> i) for i in range(n_sites-1,-1,-1)])\n\n # Create the operator corresponding to the interaction energy summed over all\n # nearest-neighbor pairs of qubits\n ZZ_filter = np.zeros_like(wf, dtype=float)\n for i in range(n_rows):\n for j in range(n_cols):\n if i < n_rows-1:\n ZZ_filter += Z[i*n_cols + j]*Z[(i+1)*n_cols + j]\n if j < n_cols-1:\n ZZ_filter += Z[i*n_cols + j]*Z[i*n_cols + (j+1)]\n\n energy_operator = -ZZ_filter - h.reshape(n_sites).dot(Z)\n\n\n # Expectation value of the energy divided by the number of sites\n return np.sum(np.abs(wf)**2 * energy_operator) / n_sites\n```\n\nWe'll also need a helper function that computes the expected value of the energy given some parameters of the QAOA.\n\n\n```\ndef energy_from_params(gamma, beta, qaoa, h):\n sim = cirq.Simulator()\n params = cirq.ParamResolver({'g':gamma, 'b':beta})\n wf = sim.simulate(qaoa, param_resolver = params).final_state\n return energy_from_wavefunction(wf, h) \n```\n\n### Training\n\nNow we need to figure out the best values of $\\gamma$ and $\\beta$ by minimizing the expectation value of the energy. We'll start by doing a brute-force search of the parameter space for illustrative purposes:\n\n\n```\n%%time\ngrid_size = 50\ngamma_max = 2\nbeta_max = 2\n\nenergies = np.zeros((grid_size,grid_size))\nfor i in range(grid_size):\n for j in range(grid_size):\n energies[i,j] = energy_from_params(i*gamma_max/grid_size, j*beta_max/grid_size, qaoa, h)\n```\n\n CPU times: user 17.9 s, sys: 0 ns, total: 17.9 s\n Wall time: 17.9 s\n\n\n\n```\nplt.ylabel('gamma')\nplt.xlabel('beta')\nplt.title('Energy as a Function of Parameters')\nplt.imshow(energies, extent=(0,beta_max,gamma_max,0));\n```\n\nBy inspection we can see that the energy function has a number of interesting properties. First, note that the function is periodic in $\\beta$ and $\\gamma$ with shorter periods than one might naively expect given the definition of the gates. The details of why that's true will take us away from the main content of this Colab, but it's a good thing to understand so that the parameter space can be efficiently truncated.\n\nThe other main thing to notice is that there are many local minima and maxima. This makes it challenging to use gradient-based methods for optimization. We'll see that explicitly next. Part of the challenge for algorithms of this type is finding efficient ways to optimize the paramters.\n\n#### Gradient Descent\n\nFor practice let's try to minimize the expectation value of the energy using gradient descent. We know that there are local minima that we might get stuck in, depending on initialization, but it's still a worthwhile exercise.\n\nThe first step is to define a function which approximates the gradient of the energy. We'll do this by symmetric difference, i.e., $f'(x) \\approx (f(x+\\epsilon)-f(x-\\epsilon))/(2\\epsilon)$. You should experiment with different values of $\\epsilon$ as well as different formulas for the gradient. \n\n\n```\ndef gradient_energy(gamma, beta, qaoa, h):\n \"\"\"Uses a symmetric difference to calulate the gradient.\"\"\"\n eps = 10**-3 # Try different values of the discretization parameter\n\n # Gamma-component of the gradient\n grad_g = energy_from_params(gamma + eps, beta, qaoa, h)\n grad_g -= energy_from_params(gamma - eps, beta, qaoa, h)\n grad_g /= 2*eps\n\n # Beta-compoonent of the gradient\n grad_b = energy_from_params(gamma, beta + eps, qaoa, h)\n grad_b -= energy_from_params(gamma, beta - eps, qaoa, h)\n grad_b /= 2*eps \n\n return grad_g, grad_b\n```\n\nNow we'll implement a gradient descent algorithm that minimizes the energy. Note that it will get stuck in local minima depending on the initialization.\n\n\n```\ngamma, beta = 0.2, 0.7 # Try different initializations\neta = 10**-2 # Try adjusting the learning rate.\nfor i in range(151):\n grad_g, grad_b = gradient_energy(gamma, beta, qaoa, h)\n gamma -= eta*grad_g\n beta -= eta*grad_b\n if not i%25:\n print('Step: {} Energy: {}'.format(i, energy_from_params(gamma, beta, qaoa, h)))\nprint('Learned gamma: {} Learned beta: {}'.format(gamma, beta, qaoa, h))\n```\n\n Step: 0 Energy: 0.3555179724197741\n Step: 25 Energy: -0.60656794301801\n Step: 50 Energy: -0.6068781974520839\n Step: 75 Energy: -0.6068778212318446\n Step: 100 Energy: -0.6068778804908308\n Step: 125 Energy: -0.6068782185651193\n Step: 150 Energy: -0.6068782066830509\n Learned gamma: 0.19753242844183583 Learned beta: 0.26843952111680774\n\n\n### Results\n\nWe've optimized our parameters. How well did we do?\n\nFor a $3\\times 3$ grid we have $9$ qubits and $12$ interacting nearest-neighbor pairs. If all of the qubits are in the $|0\\rangle$ state or all are in the $|1\\rangle$ state, then the energy-per-qubit is $-12/9 = -1.33$ at zero external magnetic field $h$, and will be close to that if the magnetic field is small. Notice that the QAOA algorithm we analyzed above is __not__ getting close to that ground state. Is this a problem?\n\nWell, not really. The QAOA algorithm still succeeds if we can find the ground state after a small numbe of measurements. The QAOA prepares a certain state which is a linear combination of the ground state and many other states. When we measure the qubits, we find the ground-state configuration with some probability. If that probability is relatively large, then after a reasonably small number of measurements we'll locate the ground state.\n\nPractically speaking, this means we should measure the state prepared by the QAOA several times and record the lowest-energy state we find. The QAOA can be successful by biasing these measurements toward the ground state, even if they do not produce the ground state with $100\\%$ probability\n\nLet's make a copy of our qaoa circuit for measurement purposes and attach a measurement gate to each qubit:\n\n\n```\nmeasurement_circuit = qaoa.copy()\nmeasurement_circuit.append(cirq.measure(*[qubit for row in qubits for qubit in row],key='m'))\nmeasurement_circuit\n```\n\n\n\n\n\n View on QuantumLib\n \n \n Run in Google Colab\n \n \n View source on GitHub\n \n \n Download notebook\n \n ┌──────────────────┐ ┌──────────────────┐\n(0, 0): ───H───ZZ─────ZZ─────Z^(0.5*g)───X^b────────────────────────────────────────────────────────────────────────────────────────────M('m')───\n │ │ │\n(0, 1): ───H───┼──────ZZ^g───ZZ──────────ZZ──────Z^(0.5*g)─────────────X^b──────────────────────────────────────────────────────────────M────────\n │ │ │ │\n(0, 2): ───H───┼─────────────┼───────────ZZ^g────ZZ────────────────────Z^(0.5*g)────X^b─────────────────────────────────────────────────M────────\n │ │ │ │\n(1, 0): ───H───ZZ^g───ZZ─────┼───────────ZZ──────┼────────Z^(0.5*g)────X^b──────────────────────────────────────────────────────────────M────────\n │ │ │ │ │\n(1, 1): ───H──────────┼──────ZZ^g────────ZZ^g────┼────────ZZ───────────ZZ───────────Z^(0.5*g)─────────────X^b───────────────────────────M────────\n │ │ │ │ │\n(1, 2): ───H──────────┼──────────────────────────ZZ^g─────┼────────────ZZ^g─────────ZZ────────────────────Z^(0.5*g)───X^b───────────────M────────\n │ │ │ │\n(2, 0): ───H──────────ZZ^g────────────────────────────────┼────────────ZZ───────────┼────────Z^(0.5*g)────X^b───────────────────────────M────────\n │ │ │ │\n(2, 1): ───H──────────────────────────────────────────────ZZ^g─────────ZZ^g─────────┼─────────────────────ZZ──────────Z^(0.5*g)───X^b───M────────\n │ │ │\n(2, 2): ───H────────────────────────────────────────────────────────────────────────ZZ^g──────────────────ZZ^g────────Z^(0.5*g)───X^b───M────────\n └──────────────────┘ └──────────────────┘\n\n\n\nNow we'll instantiate a simulator and measure the output of the circuit repeatedly:\n\n\n```\nnum_reps = 10**3 # Try different numbers of repetitions\ngamma, beta = 0.2,0.25 # Try different values of the parameters\nsimulator = cirq.Simulator()\nparams = cirq.ParamResolver({'g':gamma, 'b':beta})\nresult = simulator.run(measurement_circuit, param_resolver = params, repetitions=num_reps)\n```\n\nFinally, we'll compute the energy for each of our measurement outcoems and look at the statistics. We start with a helper function which calculates the energy given a set of measurement outcomes:\n\n\n```\ndef compute_energy(meas, h):\n Z_vals = 1-2*meas.reshape(n_rows,n_cols)\n energy = 0\n for i in range(n_rows):\n for j in range(n_cols):\n if i < n_rows-1:\n energy -= Z_vals[i, j]*Z_vals[i+1, j]\n if j < n_cols-1:\n energy -= Z_vals[i, j]*Z_vals[i, j+1]\n energy -= h[i,j]*Z_vals[i,j]\n return energy/(n_rows*n_cols)\n```\n\nNow consider the 10 most common outputs of our measurements, and compute the energies of those:\n\n\n```\nhist = result.histogram(key='m')\nnum = 10\nprobs = [v/result.repetitions for _,v in hist.most_common(num)]\nconfigs = [c for c,_ in hist.most_common(num)]\n```\n\n\n```\nplt.title('Probability of {} Most Common Outputs'.format(num))\nplt.bar([x for x in range(len(probs))],probs)\nplt.show()\nmeas = [[int(s) for s in ''.join([str(b) for b in bin(k)[2:]]).zfill(n_rows*n_cols)] for k in configs]\ncosts = [compute_energy(np.array(m), h) for m in meas]\nplt.title('Energy of {} Most Common Outputs'.format(num))\nplt.bar([x for x in range(len(costs))],costs)\nplt.show()\nprint('Fraction of outputs displayed: {}'.format(np.sum(probs).round(2)))\n```\n\nWe see that, for a good choice of $\\gamma$ and $\\beta$, ground state is the most probable outcome.\n\nTry changing the values of $\\gamma$ and $\\beta$ away from the optimal ones. You'll see that this experiment no longer finds the ground state for us.\n\n### Exercise: Experiment with Different Numbers of Layers\nSee if you can get a closer to the true ground state (i.e., a larger fraction of measurements yielding the minimal energy) by adding more layers to the circuit.\n\n### Exercise: Try Ising Model on a different graph, or With Different Interaction Strengths\nInstead of a square lattice, you can try to formulate the Ising Model on any graph you like. This just changes which qubits you link in the $U(\\gamma, C)$ layer. Each edge of the graph could also come with a different interaction coefficient, so that instead of $\\exp(i\\pi \\gamma Z_iZ_j/2)$ for that edge you would have $\\exp(i\\pi \\gamma J_{ij}Z_iZ_j/2)$ for some matrix $J_{ij}$ of coefficients. Note that you have to change both the $U(\\gamma, C)$ layer and the definition of the energy function to make this work.\n\n### Exercise: Repeat Using Sampling\n\nOn real hardware we need to use sampling to estimate expectation values.\n\nAdjust your code so that sampling is used instead of wavefunction evaluation.\n\nHow many samples do you need to take to get good results? Try different values.\n\n\n### Exercise: Transverse field Ising Model\nThe Ising Model with transverse field replaces the $\\sum h_i Z_i$ term with a $\\sum h_i X_i$ term. Can we use the QAOA here as well? What are the differences?\nThis is no longer a classical problem: in general the ground state will now be a superposition of elements of the computational basis. Can you make a circuit that prepares a state close to the gound state?\n\n", "meta": {"hexsha": "07ba65e33e30c1671b161179299cf47d742f6ef6", "size": 84224, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/educators/qaoa_ising.ipynb", "max_stars_repo_name": "lilies/Cirq", "max_stars_repo_head_hexsha": "519b8b70ba4d2d92d1c034c398161ebdbd23e2e7", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-04-06T17:06:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-04-06T17:06:10.000Z", "max_issues_repo_path": "docs/tutorials/educators/qaoa_ising.ipynb", "max_issues_repo_name": "lilies/Cirq", "max_issues_repo_head_hexsha": "519b8b70ba4d2d92d1c034c398161ebdbd23e2e7", "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/educators/qaoa_ising.ipynb", "max_forks_repo_name": "lilies/Cirq", "max_forks_repo_head_hexsha": "519b8b70ba4d2d92d1c034c398161ebdbd23e2e7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1, "max_forks_repo_forks_event_min_datetime": "2020-04-14T15:29:29.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-14T15:29:29.000Z", "avg_line_length": 74.1408450704, "max_line_length": 17136, "alphanum_fraction": 0.6811360182, "converted": true, "num_tokens": 9058, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.31742627850202554, "lm_q2_score": 0.22270014914315836, "lm_q1q2_score": 0.07069087956435881}}
{"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 Naive Bayes classifier\n\nThe Naive Bayes is a probabilistic classifier based on (surprise surprise!) the Bayes' theorem and it uses a Maximum A Priori estimate to classify the labels. \n\nIn a nutshell, its properties are:\n\n* It assumes independence among features used for the classification. \n* It is usually used for text classification\n* Is fast\n* Requires small training data\n* The probability of the outcome classification is unreliable\n\n## How does it work\n\nGiven a target variable $y$ (the class) and features $x_1, x_2, \\ldots, x_n$, by Bayes' theorem we can write\n\n$$\nP(y \\ | \\ x_1, x_2, \\ldots, x_n) = \\frac{P(x_1, x_2, \\ldots, x_n \\ | \\ y) P(y)}{P(x_1, x_2, \\ldots, x_n)} \\ ,\n$$\n\n$P(y)$ being the frequency of the class $y$.\n\nThe *naive* assumption of the algorithm is that features are independent of each other, that is, the likelihood at the second member can be factorised into the product of the likelihood of single feature:\n$$\nP(x_i | y, x_1, \\ldots, x_{i-1}, x_{i+1}, \\ldots, x_n) = P(x_i | y) \\ \\ \\ \\forall i \\ .\n$$\n\nThis way, we can simplify and write\n\n$$\nP(y \\ | \\ x_1, \\ldots, x_n) = \\frac{\\prod_{i=1}^{i=n} P(x_i \\ | \\ y) P(y)}{P(x_1, \\ldots, x_n)} \\ ,\n$$\n\nWe apply the [MAP estimation](../../prob-stats/methods/map.ipynb) to find the $y$ that maximises the posterior. The denominator only gives a constant of normalisation, so the maximising value is found via\n\n$$\n\\hat{y} = arg \\max_y P(y) \\prod_{i=1}^{i=n} P(x_i | y)\n$$\n\nWhat this means is that the classifier assigns the class label $\\hat y$ as the one which maximises the posterior probability.\n\n## The different classifiers in the family (some cases)\n\nThe different Naive Bayes classifiers differ in the assumptions for the likelihood distribution $P(x_i | y)$.\n\n### Gaussian Naive Bayes\n\nIn a Gaussian Naive Bayes, it is assumed to be a gaussian:\n\n$$\nP(x_i | y) = \\frac{1}{\\sqrt{2 \\pi \\sigma_y^2}} e^{- \\frac{(x_i - \\mu_y)^2}{2 \\sigma_y^2}} \\ ,\n$$\n\nwith parameters $\\mu_y$ and $\\sigma_y$ being the mean and the standard deviation of feature $x_i$ in class $y$, estimated using the Maximum Likelihood estimation.\n\n### Bernoulli Naive Bayes\n\nIn a Bernoulli Naive Bayes, used when features are binary, it is assumed that \n\n$$\nP(x_i | y) = P(i | y) x_i + (1 - P(i | y))(1-x_i) \\ .\n$$\n\n### Multinomial Naive Bayes\n\nIn a Multinomial Naive Bayes, with feature vector $\\mathbf{x}$ and $k_i$ being the number of successes for variable $x_i$, the likelihood is given as\n\n$$\nP(\\mathbf{x} | y_k) = \\frac{\\Big(\\sum_i x_i\\Big)!}{\\prod_i x_i!} \\prod p_{k_i}^{x_i}\n$$\n\nNote that the multinomial Naive Bayes classifier becomes a linear classifier when expressed in logarithmic scale:\n\n\\begin{align}\n\\log P(y_k | \\mathbf{x}) &\\propto \\log \\Big[p(y_k) \\prod_{i=1}^n p_{k_i}^{x_i}\\Big] \\\\\n&= \\log p(y_k) + \\sum_{i=1}^n x_i \\log p_{k_i} \\\\\n&= b + \\mathbf{w}_k^t \\mathbf{x}\n\\end{align}\n\nwith $b = \\log p(y_k)$ (a constant) and $\\mathbf{w}_k = \\log p_{k_i}$.\n\n## Regularised Naive Bayes: the smoothing\n\nIf in the training data there is no value for which feature $x_i$ is determined by the class $y$, meaning there is no occurrences where feature and class are together, the likelihood would equal zero: this is a problem as there would be a zero in the multiplication.\n\nA correction to remedy this problem (*regularised Naive Bayes*) is obtained via adding an addend in the calculation of the likelihood as a frequency so as to have a small but non-zero probability. While in general we would calculate it as\n\n$$\np_i = \\frac{n_i}{n_y} \\ ,\n$$\n\nwhere $n_i$ is the number of times feature $x_i$ appears in the sample for class $y$ in the training set and $n_y$ is the total count of occurrences of class $y$, we smoothen as\n\n$$\np_i = \\frac{n_i + \\alpha}{n_y + \\alpha n}\n$$\n\nwhere $\\alpha$ is a chosen factor and $n$ the number of possible values for feature $x_i$. This procedure is called *Lidstone smoothing*, with $\\alpha = 1$ it's the *Laplace smoothing*.\n\n## An example: sex classification\n\nThis small example, as well as the ones below are taken and reworked from [the Wikipedia page on the topic](https://en.wikipedia.org/wiki/Naive_Bayes_classifier#Sex_classification). The problem is about classifying if a person is a male (M) or a female (F) based on height (h, in feet), weight (w, in pounds) and foot size (f, in inches). This is the training data we assume to have collected:\n\n| Gender | h (feet) | w (lbs) | f (inches) |\n| ------ |:--------:| :------:| :--------: | \n| M | 6 | 180 | 12 | \n| M | 5.92 | 190 | 11 | \n| M | 5.58 | 170 | 12 | \n| M | 5.92 | 165 | 10 | \n| F | 5 | 100 | 6 | \n| M | 5.5 | 150 | 8 | \n| M | 5.42 | 130 | 7 | \n| M | 5.75 | 150 | 9 | \n\n\nWe use a gaussian assumption, so we assume the likelihood for each feature to be\n\n$$\nP(x_i | y) = \\frac{1}{\\sqrt{2 \\pi \\sigma_y^2}} e^{- \\frac{(x_i - \\mu_y)^2}{2 \\sigma_y^2}}\n$$\n\nand we estimate the parameters of said gaussians via [MLE](../../prob-stats/methods/mle.ipynb), obtaining:\n\n| Gender | $\\mu_h$ | $\\sigma^2_h$ | $\\mu_w$ | $\\sigma^2_w$ | $\\mu_f$ | $\\sigma^2_f$ |\n| ------ |:-------:| :---------:| :-----: | :----------: | :-----: | :----------: |\n| M | 5.86 | $3.5 \\cdot 10^{-2}$ | 176.25 | $1.23 \\cdot 10^2$ | 11.25 | $9.19 \\cdot 10^{-1}$ |\n| F | 5.42 | $9.72 \\cdot 10^{-2}$ | 132.5 | $5.58 \\cdot 10^2$ | 7.5 | 1.67 |\n\nThe two classes are equiprobable because we got the same number of training points for each, so $P(M) = P(F) = 0.5$, and these are the priors for each class. Note that we could also give the priors from the population, assuming that each gender is equiprobable.\n\nNow, given a new sample point whose height is 6 feet, weight 130 lbs and foot size 8 inches, we want to classify its gender, so we determine which class maximises the posterior:\n\n$$\nP(M | h, w, f) = \\frac{P(h, w, f | M) P(M)}{P(E)} \\ ,\n$$\n\nwhere, under the Naive Bayes assumption,\n\n$$\nP(h, w, f | M) = P(h | M) P(w | M) P(f | M) \\ ,\n$$\n\nand \n\n$$\nP(E) = P(h, w, f | M)P(M) + P(h, w, f | F)P(F) \\ ,\n$$\n\nwhich is just a normalising constant so can be ignored. Now,\n\n$$\nP(h | M) = \\frac{1}{\\sqrt{2 \\pi \\sigma^2}} e^{- \\frac{(6 - \\mu)^2}{2 \\sigma^2}} \\approx 1.5789\n$$\n\nIn the same way we compute $P(w | M) = 5.9881 \\cdot 10^{-6}$ and $P(f | M) = 1.3112 \\cdot 10^{-3}$, so that in the end we obtain $P(M | h, w, f) = 6.1984 \\cdot 10^{-9}$. Similarly we get $P(F | h, w, f) = 5.3779 \\cdot 10^{-4}$, which is larger so we predict that the sample is a female.\n\n## Other examples, on classifying text\n\n### Spam filter\n\nThis is a common application of a Naive Bayes classifier and it is a case of text classification. \n\nSome words are more frequent than others in spam e-mails (for example \"Viagra\" is definitely a recurring word in spam e-mails). The user manually and continuously trains the filter of their e-mail provider by indicating whether a mail is spam or not. For all words in each training mail, the filter then adjusts the probability that it will appear in a spam or legitimate e-mail.\n\nLet $S$ be the event that an e-mail is spam and $w$ a word, then we compute the probability that an e-mail is spam given that it contains $w$ as ($\\neg S$ is the event that mail is not spam, or \"ham\"):\n\n$$\nP(S | w) = \\frac{P(w | S) P(S)}{P(w | S) P(S) + P(w | \\neg S) P(\\neg S)} \\ ,\n$$\n\nwhere $P(S)$, the prior, is the probability that a message is spam in general, and $P(w | S)$ is the probability that $w$ appears in spam messages. \n\nA non biased filter will assume $P(S) = P(\\neg S) = 0.5$, biased filters will assume higher probability for mail being spam. $P(S | w)$ is approximated by the frequency of mails containing word $w$ and being identified as spam in the learning phase, and similarly for $P(w | \\neg S)$. \n\nNow, this is valid for a single word, but a functional spam classifier uses several words and a Naive Bayes hypothesis, assuming that the presence of each word is an independent event. Note that this is a crude assumption as in reality in natural language words co-occurrence is key. Nevertheless, it is a useful idealisation, useful for the calculation in the Naive Bayes fashion.\n\nSo, with more words considered [[1]](#graham),\n\n$$\nP(S | w_1, \\ldots, w_n) = \\frac{P(w_1 | S) \\cdots P(w_N | S)}{P(w_1 | S) \\cdots P(w_N | S) + P(w_1 | \\neg S) \\cdots P(w_N | \\neg S)}\n$$\n\n### Text classification\n\nGiven texts which can fall into categories (for example literary genres), we use\n\n$$\nP(C | w_1, \\ldots, w_n) = \\frac{\\Pi_{i=1}^n P(w_i | C) P(C)}{\\mathcal{N}}\n$$\n\nwith $C$ being the genre, $w_i$ the words and the denominator is an irrelevant factor.\n\nWith a bag of words approach, if we have a training set $D$ and a vocabulary $V$ containing all the words in the documents, considering $D_i$ the subset of texts in category $C_i$, then\n\n$$\nP(C_i) = \\frac{|D_i|}{|D|}\n$$\n\n(fraction of samples in category $C_i$). Now, we concatenate all documents in $D_i$, obtaining $n_i$ words and $\\forall w_j \\in V$ we call $n_{ij}$ the number of occurrences of $w_j$ in $D_i$, so\n\n$$\nP(w_j | C_i) = \\frac{n_{ij} + 1}{n_i + |V|}\n$$\n\n(we use smoothing). The predicted category is then\n\n$$\narg \\max_{C_k \\in \\mathcal{C}} P(C_k) \\Pi_{i=1}^n P(w_i | C_k)\n$$\n\n## References\n\n1. P Graham, [*A Plan for Spam*](http://www.paulgraham.com/spam.html), 2002\n\n\n```python\n\n```\n", "meta": {"hexsha": "2450bb87dacca5c02a99b3db76402baff297b666", "size": 15826, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "ml-algorithms/supervised/nb.ipynb", "max_stars_repo_name": "walkenho/tales-science-data", "max_stars_repo_head_hexsha": "4f271d78869870acf2b35ce54d40766af7dfa348", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1, "max_stars_repo_stars_event_min_datetime": "2020-05-11T09:39:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-11T09:39:10.000Z", "max_issues_repo_path": "ml-algorithms/supervised/nb.ipynb", "max_issues_repo_name": "walkenho/tales-science-data", "max_issues_repo_head_hexsha": "4f271d78869870acf2b35ce54d40766af7dfa348", "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": "ml-algorithms/supervised/nb.ipynb", "max_forks_repo_name": "walkenho/tales-science-data", "max_forks_repo_head_hexsha": "4f271d78869870acf2b35ce54d40766af7dfa348", "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.8639798489, "max_line_length": 402, "alphanum_fraction": 0.5202830785, "converted": true, "num_tokens": 3595, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.34158249943831703, "lm_q2_score": 0.2068940439256578, "lm_q1q2_score": 0.07067138464302715}}
{"text": "# Language Classification with Naive Bayes in Python\n\n## Recommended Prerequisites for Successful Completion\n* Intermediate level understanding of Python 3+ (e.g. list and dictionary comprehension)\n* Basics of machine learning (e.g. the distinction between training and validation data)\n* Mathematical probability (e.g. understanding Bayes' Theorem at a basic level)\n\n\n## Project Outline\n[**Introduction**](#intro)\n\n[**Task 1**](#task1): Exploratory Data Analysis + Visualization\n\n[**Task 2**](#task2): Data Cleaning and Preprocessing\n\n[**Task 3**](#task3): Naive Bayes Model Introduction and Training\n\n[**Task 4**](#task4): Highlighting Problems with Basic Model and Simple Fixes\n\n[**Task 5**](#task5): Advanced Approach to Further Improve Performance\n\n\n```python\nimport matplotlib\n%matplotlib inline\n%config InlineBackend.figure_format = 'svg'\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')\n\nimport numpy as np\nimport string\n\nfrom collections import defaultdict\n\nfrom sklearn.metrics import f1_score\nfrom sklearn.naive_bayes import MultinomialNB\nfrom sklearn.feature_extraction.text import CountVectorizer\n\nimport joblib\nimport pickle as pkl\n\nfrom helper_code import *\n```\n\n\n# Introduction\n\n\n```python\nmodel = joblib.load('Data/Models/final_model.joblib')\nvectorizer = joblib.load('Data/Vectorizers/final_model.joblib')\n```\n\n## [Slovak Wikipedia Entry](https://sk.wikipedia.org/wiki/Jazveč%C3%ADk)\nMnohí ľudia, ktorí vidia na ulici jazvečíka s podlhovastým telom vôbec nevedia o tom, že tento malý štvornohý a veľmi obľúbený spoločník je pri dobrom výcviku obratným, vynikajúcim a spoľahlivým poľovným psom. Ako poľovný pes je mnohostranne využiteľný, okrem iného ako durič na brlohárenie. Králičí jazvečík sa dokáže obratne pohybovať v králičej nore. S inými psami a deťmi si nie vždy rozumie.\n\n## [Czech Wikipedia Entry](https://cs.wikipedia.org/wiki/Jezevč%C3%ADk)\nÚplně první zmínky o psech podobných dnešním jezevčíkům nacházíme až ve Starém Egyptě, kde jsou vyobrazeni na soškách a rytinách krátkonozí psi s dlouhým hřbetem a krátkou srstí. Jednalo se ale o neustálený typ bez ustáleného jména. Další zmínky o jezevčících nacházíme až ve 14 - 15. století. Jedná se o psa, který se nejvíce podobá dnešnímu typu hladkosrstého standardního jezevčíka.\n\n\n## [English Wikipedia Entry](https://en.wikipedia.org/wiki/Dachshund)\nWhile classified in the hound group or scent hound group in the United States and Great Britain, the breed has its own group in the countries which belong to the Fédération Cynologique Internationale (World Canine Federation). Many dachshunds, especially the wire-haired subtype, may exhibit behavior and appearance that are similar to that of the terrier group of dogs.\n\n\n```python\ntext = 'okrem iného ako durič na brlohárenie'\ntext = preprocess_function(text)\ntext = [split_into_subwords_function(text)]\ntext_vectorized = vectorizer.transform(text)\n\nmodel.predict(text_vectorized)\n\n```\n\n\n\n\n array(['sk'], dtype='
\n \n
\n \n \n \n \n \n \n \n \n \n \nFor Loop
\n \n \n
\n\n \n \n \n \n ID \n Name \n InChI \n InChIKey \n SMILES \n Solubility \n SD \n Ocurrences \n Group \n MolWt \n ... \n NumAromaticRings \n NumSaturatedRings \n NumAliphaticRings \n RingCount \n TPSA \n LabuteASA \n BalabanJ \n BertzCT \n processed_smiles \n class \n \n \n 0 \n A-3 \n N,N,N-trimethyloctadecan-1-aminium bromide \n InChI=1S/C21H46N.BrH/c1-5-6-7-8-9-10-11-12-13-... \n SZEMGTQCPRNXEG-UHFFFAOYSA-M \n [Br-].CCCCCCCCCCCCCCCCCC[N+](C)(C)C \n -3.616127 \n 0.0 \n 1 \n G1 \n 392.510 \n ... \n 0.0 \n 0.0 \n 0.0 \n 0.0 \n 0.00 \n 158.520601 \n 0.000000 \n 210.377334 \n CCCCCCCCCCCCCCCCCC[N+](C)(C)C \n slightly soluble \n \n \n 1 \n A-4 \n Benzo[cd]indol-2(1H)-one \n InChI=1S/C11H7NO/c13-11-8-5-1-3-7-4-2-6-9(12-1... \n GPYLCFQEKPUWLD-UHFFFAOYSA-N \n O=C1Nc2cccc3cccc1c23 \n -3.254767 \n 0.0 \n 1 \n G1 \n 169.183 \n ... \n 2.0 \n 0.0 \n 1.0 \n 3.0 \n 29.10 \n 75.183563 \n 2.582996 \n 511.229248 \n O=C1Nc2cccc3cccc1c23 \n slightly soluble \n \n \n 2 \n A-5 \n 4-chlorobenzaldehyde \n InChI=1S/C7H5ClO/c8-7-3-1-6(5-9)2-4-7/h1-5H \n AVPYQKSLYISFPO-UHFFFAOYSA-N \n Clc1ccc(C=O)cc1 \n -2.177078 \n 0.0 \n 1 \n G1 \n 140.569 \n ... \n 1.0 \n 0.0 \n 0.0 \n 1.0 \n 17.07 \n 58.261134 \n 3.009782 \n 202.661065 \n O=Cc1ccc(Cl)cc1 \n slightly soluble \n \n \n 3 \n A-10 \n vinyltoluene \n InChI=1S/C9H10/c1-3-9-6-4-5-8(2)7-9/h3-7H,1H2,2H3 \n JZHGRUMIRATHIU-UHFFFAOYSA-N \n Cc1cccc(C=C)c1 \n -3.123150 \n 0.0 \n 1 \n G1 \n 118.179 \n ... \n 1.0 \n 0.0 \n 0.0 \n 1.0 \n 0.00 \n 55.836626 \n 3.070761 \n 211.033225 \n C=Cc1cccc(C)c1 \n slightly soluble \n \n \n \n4 \n A-11 \n 3-(3-ethylcyclopentyl)propanoic acid \n InChI=1S/C10H18O2/c1-2-8-3-4-9(7-8)5-6-10(11)1... \n WVRFSLWCFASCIS-UHFFFAOYSA-N \n CCC1CCC(CCC(O)=O)C1 \n -3.286116 \n 0.0 \n 1 \n G1 \n 170.252 \n ... \n 0.0 \n 1.0 \n 1.0 \n 1.0 \n 37.30 \n 73.973655 \n 2.145839 \n 153.917569 \n CCC1CCC(CCC(=O)O)C1 \n slightly soluble \n \n \n
\n\n \n \n \n \n 0 \n \n \n MolLogP \n 0.618195 \n \n \n MolWt \n 0.451355 \n \n \n MolMR \n 0.444390 \n \n \n LabuteASA \n 0.423057 \n \n \n \nNumValenceElectrons \n 0.366864 \n \n \n
\n\n \n \n \n \n 0 \n \n \n NumRotatableBonds \n 0.080012 \n \n \n NumHeteroatoms \n 0.070472 \n \n \n NumHDonors \n 0.059317 \n \n \n NumAliphaticRings \n 0.024100 \n \n \n \nNumSaturatedRings \n 0.019100 \n [75.12] Análisis Numérico
\nTrabajo Práctico 1
\n1er Cuatrimestre 2021
\n\n--- \n\nBúsqueda de raíces
\n\n---\n\nAUTOR
\nCÁTEDRA
\nFECHA DE ENTREGA
\nLENGUAJE ELEGIDO
\nCALIFICACIÓN
\n\n\n---\n\n*Es importante correr todos los bloques de código si se quiere visualizar algún resultado ya que algunos dependen de bloques previos.*\n\n\n```python\nimport numpy as np\nfrom sympy import *\nfrom matplotlib import pyplot as plt\nfrom scipy import optimize\nimport matplotlib.ticker as mticker\nnp.seterr('raise')\n```\n\n\n\n\n {'divide': 'warn', 'invalid': 'warn', 'over': 'warn', 'under': 'ignore'}\n\n\n\n\n```python\n# Función auxiliar para imprimir iteraciones\ndef imprimir_iteraciones(iteraciones, cant_semillas = 1, n_mostrar = 0):\n print(\"#\\t\\t\\t Valor calculado\\t\\t Variación respecto al anterior\")\n print(*[f\"Semilla {x}\\t\\t\"+f\"{iteraciones[x] : 1.20f}\"[:18] for x in range (0, cant_semillas)], sep = '\\n')\n print(*[f\"Iteracion {x}\\t\\t\"+f\"{iteraciones[x] : 1.20f}\"[:18]+\"\\t\\t\"+f\"{abs(iteraciones[x-1] - iteraciones[x]) : 1.20f}\"[:18] for x in range(cant_semillas, len(iteraciones))], sep = '\\n')\n\n# Función auxiliar para obtener la tolerancia al considerar un número 0. Tipo debe ser np.float32 o np.float64\ndef tol_cero(tipo):\n return np.float32(2)**np.float32(-120) if tipo == np.float32 else np.float64(2)**np.float64(-1000)\n```\n\n# 1. Métodos para seres queridos\n\nEn el marco de la época de la pandemia poder ayudar a los seres queridos es lo más importante que podemos hacer.\n\n## (a) Buscar la forma de implementar un método visto en clase para ayudar o apoyar a un ser querido. De no ser posible dar un ejemplo de un uso de los métodos vistos en clase para el área en que se desarrollen profesionalmente.\n\n\n
\n\nmenggunakan kode HTML berikut\n\n```html\n\n \n Titik $x$ $y$ $z$ \n \n \n A 1 2 3 \n \n \nB -1 -2 -3 \n \n
\n```\n\n\n```python\n\n```\n", "meta": {"hexsha": "e5ece08138de240196f0c22024a9f848d1b491a5", "size": 20467, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "notebook/external/embed_svg.ipynb", "max_stars_repo_name": "dudung/cookbook", "max_stars_repo_head_hexsha": "8a43a923af8367dafd04e3dd2ef6b9e7ed82b22f", "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/external/embed_svg.ipynb", "max_issues_repo_name": "dudung/cookbook", "max_issues_repo_head_hexsha": "8a43a923af8367dafd04e3dd2ef6b9e7ed82b22f", "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/external/embed_svg.ipynb", "max_forks_repo_name": "dudung/cookbook", "max_forks_repo_head_hexsha": "8a43a923af8367dafd04e3dd2ef6b9e7ed82b22f", "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": 52.3452685422, "max_line_length": 6312, "alphanum_fraction": 0.7561440367, "converted": true, "num_tokens": 1312, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.2974699426047947, "lm_q2_score": 0.2309197682220399, "lm_q1q2_score": 0.06869169019932271}}
{"text": "```python\nimport discretize\n```\n\n\n```python\nmesh = discretize.TensorMesh([3, 4])\n```\n\n\n```python\nmesh\n```\n\n\n\n\n\n \n Titik $x$ $y$ $z$ \n \n \n A 1 2 3 \n \n \nB -1 -2 -3 \n \n
\n\n\n\n\n# Rich Output\n\nIn Python, objects can declare their textual representation using the `__repr__` method. IPython expands on this idea and allows objects to declare other, rich representations including:\n\n* HTML\n* JSON\n* PNG\n* JPEG\n* SVG\n* LaTeX\n\nA single object can declare some or all of these representations; all are handled by IPython's *display system*. This Notebook shows how you can use this display system to incorporate a broad range of content into your Notebooks.\n\n## Basic display imports\n\nThe `display` function is a general purpose tool for displaying different representations of objects. Think of it as `print` for these rich representations.\n\n\n```python\n# display is injected in default namespace, but it's a good idea to be explicit.\nfrom IPython.display import display\n```\n\nA few points:\n\n* Calling `display` on an object will send **all** possible representations to the Notebook.\n* These representations are stored in the Notebook document.\n* In general the Notebook will use the richest available representation.\n\nIf you want to display a particular representation, there are specific functions for that:\n\n\n```python\nfrom IPython.display import (\n display_pretty, display_html, display_jpeg,\n display_png, display_json, display_latex, display_svg\n)\n```\n\n## Images\n\nTo work with images (JPEG, PNG) use the `Image` class.\n\n\n```python\nfrom IPython.display import Image\n```\n\n\n```python\ni = Image(filename='./images/ipython-logo.png')\n```\n\nReturning an `Image` object from an expression will automatically display it:\n\n\n```python\ni\n```\n\nOr you can pass an object with a rich representation to `display`:\n\n\n```python\ndisplay(i)\n```\n\nAn image can also be displayed from raw data or a URL.\n\n\n```python\nImage(url='http://python.org/images/python-logo.gif')\n```\n\n\n\n\n\n\n\n\nSVG images are also supported out of the box.\n\n\n```python\nfrom IPython.display import SVG\nSVG(filename='./images/python-logo.svg')\n```\n\n\n\n\n \n\n \n\n\n\n### Embedded vs non-embedded Images\n\nBy default, image data is embedded in the notebook document so that the images can be viewed offline. However it is also possible to tell the `Image` class to only store a *link* to the image. Let's see how this works using a webcam at Berkeley.\n\n\n```python\nfrom IPython.display import Image\nimg_url = 'http://www.lawrencehallofscience.org/static/scienceview/scienceview.berkeley.edu/html/view/view_assets/images/newview.jpg'\n\n# by default Image data are embedded\nEmbed = Image(img_url)\n\n# if kwarg `url` is given, the embedding is assumed to be false\nSoftLinked = Image(url=img_url)\n\n# In each case, embed can be specified explicitly with the `embed` kwarg\n# ForceEmbed = Image(url=img_url, embed=True)\n```\n\nHere is the embedded version. Note that this image was pulled from the webcam when this code cell was originally run and stored in the Notebook. Unless we rerun this cell, this is not todays image.\n\n\n```python\nEmbed\n```\n\n\n\n\n \n\n \n\n\n\nHere is today's image from same webcam at Berkeley, (refreshed every minutes, if you reload the notebook), visible only with an active internet connection, that should be different from the previous one. Notebooks saved with this kind of image will be smaller and always reflect the current version of the source, but the image won't display offline.\n\n\n```python\nSoftLinked\n```\n\n\n\n\n\n\n\n\nOf course, if you re-run this Notebook, the two images will be the same again.\n\n## HTML\n\nPython objects can declare HTML representations that will be displayed in the Notebook. If you have some HTML you want to display, simply use the `HTML` class.\n\n\n```python\nfrom IPython.display import HTML\n```\n\n\n```python\ns = \"\"\"\n \n TensorMesh \n 12 cells \n \n \n \n \n MESH EXTENT \n CELL WIDTH \n FACTOR \n \n \n dir \n nC \n min \n max \n min \n max \n max \n \n \n x \n 3 \n 0.00 \n 1.00 \n 0.33 \n 0.33 \n 1.00 \n \n \ny \n 4 \n 0.00 \n 1.00 \n 0.25 \n 0.25 \n 1.00 \n \n
\"\"\"\n```\n\n\n```python\nh = HTML(s)\n```\n\n\n```python\ndisplay(h)\n```\n\n\n\n \nHeader 1 \nHeader 2 \n\n \nrow 1, cell 1 \nrow 1, cell 2 \n\n \nrow 2, cell 1 \nrow 2, cell 2 \n\n
\n\n\nYou can also use the `%%html` cell magic to accomplish the same thing.\n\n\n```python\n%%html\n\n \nHeader 1 \nHeader 2 \n\n \nrow 1, cell 1 \nrow 1, cell 2 \n\n \nrow 2, cell 1 \nrow 2, cell 2 \n\n
\n```\n\n\n\n \nHeader 1 \nHeader 2 \n\n \nrow 1, cell 1 \nrow 1, cell 2 \n\n \nrow 2, cell 1 \nrow 2, cell 2 \n\n
\n\n\n\n## LaTeX\n\nThe IPython display system also has builtin support for the display of mathematical expressions typeset in LaTeX, which is rendered in the browser using [MathJax](http://mathjax.org).\n\nYou can pass raw LaTeX test as a string to the `Math` object:\n\n\n```python\nfrom IPython.display import Math\nMath(r'F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx')\n```\n\n\n\n\n$\\displaystyle F(k) = \\int_{-\\infty}^{\\infty} f(x) e^{2\\pi i k} dx$\n\n\n\nWith the `Latex` class, you have to include the delimiters yourself. This allows you to use other LaTeX modes such as `eqnarray`:\n\n\n```python\nfrom IPython.display import Latex\nLatex(r\"\"\"\\begin{eqnarray}\n\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\\n\\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n\\nabla \\cdot \\vec{\\mathbf{B}} & = 0 \n\\end{eqnarray}\"\"\")\n```\n\nOr you can enter LaTeX directly with the `%%latex` cell magic:\n\n\n```latex\n%%latex\n\\begin{align}\n\\nabla \\times \\vec{\\mathbf{B}} -\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{E}}}{\\partial t} & = \\frac{4\\pi}{c}\\vec{\\mathbf{j}} \\\\\n\\nabla \\cdot \\vec{\\mathbf{E}} & = 4 \\pi \\rho \\\\\n\\nabla \\times \\vec{\\mathbf{E}}\\, +\\, \\frac1c\\, \\frac{\\partial\\vec{\\mathbf{B}}}{\\partial t} & = \\vec{\\mathbf{0}} \\\\\n\\nabla \\cdot \\vec{\\mathbf{B}} & = 0\n\\end{align}\n```\n\n## Audio\n\nIPython makes it easy to work with sounds interactively. The `Audio` display class allows you to create an audio control that is embedded in the Notebook. The interface is analogous to the interface of the `Image` display class. All audio formats supported by the browser can be used. Note that no single format is presently supported in all browsers.\n\n\n```python\nfrom IPython.display import Audio\nAudio(url=\"http://www.nch.com.au/acm/8k16bitpcm.wav\")\n```\n\n\n\n\n\n\n\n\n\n\nA NumPy array can be auralized automatically. The `Audio` class normalizes and encodes the data and embeds the resulting audio in the Notebook.\n\nFor instance, when two sine waves with almost the same frequency are superimposed a phenomena known as [beats](https://en.wikipedia.org/wiki/Beat_%28acoustics%29) occur. This can be auralised as follows:\n\n\n```python\nimport numpy as np\nmax_time = 3\nf1 = 220.0\nf2 = 224.0\nrate = 8000\nL = 3\ntimes = np.linspace(0,L,rate*L)\nsignal = np.sin(2*np.pi*f1*times) + np.sin(2*np.pi*f2*times)\n\nAudio(data=signal, rate=rate)\n```\n\n\n\n\n\n\n\n\n\n\n## Video\n\nMore exotic objects can also be displayed, as long as their representation supports the IPython display protocol. For example, videos hosted externally on YouTube are easy to load:\n\n\n```python\nfrom IPython.display import YouTubeVideo\nYouTubeVideo('sjfsUzECqK0')\n```\n\n\n\n\n\n\n\n\n\n\nUsing the nascent video capabilities of modern browsers, you may also be able to display local\nvideos. At the moment this doesn't work very well in all browsers, so it may or may not work for you;\nwe will continue testing this and looking for ways to make it more robust. \n\nThe following cell loads a local file called `animation.m4v`, encodes the raw video as base64 for http\ntransport, and uses the HTML5 video tag to load it. On Chrome 15 it works correctly, displaying a control bar at the bottom with a play/pause button and a location slider.\n\n\n```python\nfrom IPython.display import HTML, Video\nfrom base64 import b64encode\nvideo = open(\"images/animation.m4v\", \"rb\").read()\nvideo_encoded = b64encode(video).decode('ascii')\nvideo_tag = '\n\n\n\n## External sites\n\nYou can even embed an entire page from another site in an iframe; for example this is today's Wikipedia\npage for mobile users:\n\n\n```python\nfrom IPython.display import IFrame\nIFrame('http://jupyter.org', width='100%', height=350)\n```\n\n\n\n\n\n\n\n\n\n\n## Rich output and security\n\nThe IPython Notebook allows arbitrary code execution in both the IPython kernel and in the browser, though HTML and JavaScript output. More importantly, because IPython has a JavaScript API for running code in the browser, HTML and JavaScript output can actually trigger code to be run in the kernel. This poses a significant security risk as it would allow IPython Notebooks to execute arbitrary code on your computers.\n\nTo protect against these risks, the IPython Notebook has a security model that specifies how dangerous output is handled. Here is a short summary:\n\n* When you run code in the Notebook, all rich output is displayed.\n* When you open a notebook, rich output is only displayed if it doesn't contain security vulberabilities, ...\n* ... or if you have trusted a notebook, all rich output will run upon opening it.\n\nA full description of the IPython security model can be found on [this page](http://ipython.org/ipython-doc/dev/notebook/security.html).\n", "meta": {"hexsha": "786cd34bfc071428e3d0c7ee827bd2db4932312a", "size": 429811, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "04.Jupyter_and_iPython/appendix/a-01-Rich Output.ipynb", "max_stars_repo_name": "scottyhq/2020_ICESat-2_Hackweek_Tutorials", "max_stars_repo_head_hexsha": "a655b29f124d3799242f0019c6686e8e45d384a1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 56, "max_stars_repo_stars_event_min_datetime": "2020-07-24T15:20:19.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-09T03:08:31.000Z", "max_issues_repo_path": "04.Jupyter_and_iPython/appendix/a-01-Rich Output.ipynb", "max_issues_repo_name": "scottyhq/2020_ICESat-2_Hackweek_Tutorials", "max_issues_repo_head_hexsha": "a655b29f124d3799242f0019c6686e8e45d384a1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4, "max_issues_repo_issues_event_min_datetime": "2020-08-26T13:19:27.000Z", "max_issues_repo_issues_event_max_datetime": "2021-04-20T15:50:57.000Z", "max_forks_repo_path": "04.Jupyter_and_iPython/appendix/a-01-Rich Output.ipynb", "max_forks_repo_name": "scottyhq/2020_ICESat-2_Hackweek_Tutorials", "max_forks_repo_head_hexsha": "a655b29f124d3799242f0019c6686e8e45d384a1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 27, "max_forks_repo_forks_event_min_datetime": "2020-06-30T07:41:04.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-06T08:36:25.000Z", "avg_line_length": 393.9605866178, "max_line_length": 239833, "alphanum_fraction": 0.9357671162, "converted": true, "num_tokens": 49407, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.49609382947091946, "lm_q2_score": 0.1384617852362804, "lm_q1q2_score": 0.06869003727324635}}
{"text": "# Encoding of categorical variables\n\n## Sources\n\n* [Encoding categorical variables](https://kiwidamien.github.io/encoding-categorical-variables.html)\n* [Benchmarking Categorical Encoders](https://towardsdatascience.com/benchmarking-categorical-encoders-9c322bd77ee8)\n* [Smarter Ways to Encode Categorical Data for Machine Learning](https://towardsdatascience.com/smarter-ways-to-encode-categorical-data-for-machine-learning-part-1-of-3-6dca2f71b159)\n* [Encoding Categorical Variables in Practice](https://medium.com/epfl-extension-school/encoding-categorical-variables-in-practice-a536907f2013)\n* [Types of Categorical Data Encoding Schemes](https://medium.com/analytics-vidhya/types-of-categorical-data-encoding-schemes-a5bbeb4ba02b)\n* [Guide to Encoding Categorical Values in Python ](https://pbpython.com/categorical-encoding.html)\n* [All about Categorical Variable Encoding](https://towardsdatascience.com/all-about-categorical-variable-encoding-305f3361fd02)\n* [Encoding categorical variables: one-hot and beyond](http://www.win-vector.com/blog/2017/04/encoding-categorical-variables-one-hot-and-beyond/)\n\n# Background\n\nMany machine learning algorithms are not able to use non-numeric data. While many features we might use, such as a person's age, or height, are numeric there are many that are not. Usually these features are represented by strings, and we need some way of transforming them to numbers before using scikit-learn's algorithms. The different ways of doing this are called encodings.\n\n**Note**:This notebook does not address the translation of text into numbers/vectors. This is the topic of __word embeddings__ where the aim is to generate vectors such that words with similar meaning are close to one another and that the arithmetic of vectors corresponds to ''arithmetic'' of meaning, e.g. embedding('queen') ~ embedding('king') - embedding('man') + embedding('woman').\n\n## Terminology\n\n**Levels**: A levels of a non-numeric feature are the number of distinct values. The examples listed above are all examples of levels. The number of levels can vary wildly: the number of races for a patient is typically four (asian, black, hispanic, and white), the number of states for the US is 51 (if we include DC separately), while the number of professions is in the thousands.\n\n**Ordinal**: If the levels are ordered, then we call the feature ordinal. For example, if a class grade such as \"B+\" or \"A\" is a non-numeric feature, but the letters are not just different, they are ordered (an \"A\" is better than a \"B+\", which is better than a \"C-\" etc).\n\n**Nominal**: If the levels are just different without an ordering, we call the feature categorical. For example, professions or car brands are categorical. If we use an encoding that maps levels to numbers, we introduce an ordering on the categories, which may not be desirable. Most of this article will be about encoding categorical variables.\n\n## Considerations when choosing encodings\n\n**Do you have many levels?** If so, using an encoding that has a level-per-feature is difficult for tree-based models. Trees separate on features that \"split\" the data into different classes effectively. If there are many levels, it is likely only a tiny fraction of the data belong to one level, so it will be hard for trees to \"find\" that feature to split on. Typically this isn't a problem for linear models.\n\n**Are there many examples of each level?** If there are only 5 doctors in your dataset, you probably are not going to know the doctor category very well (nor will it generalize). Some encoders deal with this gracefully, while others won't. You might consider making an explicit \"other\" category for levels, or grouping categories together. This is a problem for all models.\n\n**Could you have new categories at test time?** Some categorical variables can be completely specified at training time (e.g. the levels for race or blood type would be known even with zero training examples). Other categories, such as profession, are so broad that we probably learn the levels from the training data. Some encoders deal with levels that are only in the test set better than others.\n\n**Are the categories related?** Many encoding schemes treat two different levels as \"equally different\" from one another. If looking at color of a car, a typical encoding has no idea that \"brick red\" and \"red\" are more related than \"red\" and \"yellow\". One way of solving this problem is to cluster the categories into higher levels, and then encode that category as well.\n\n**Is it reversible?** Does it store a lookup table? Given the encoding of a feature, can you recover the original value? If so, we call the encoding reversible. Generally, reversible features also require a lot of storage if there are a lot of levels (to figure out how to go backward). I would generally see reversible as a negative if it requries storing a lookup table as well.\n\n## Example data\n\n\n```python\nimport requests\nimport category_encoders as ce\nimport numpy as np\nimport pandas as pd\n\ndef encode_var(var, encoder, y=None):\n if y is None:\n encoder.fit(var)\n else:\n encoder.fit(var, y)\n new_var = encoder.transform(var)\n if isinstance(new_var, pd.DataFrame):\n new_var.insert(0, 'original', var)\n return new_var\n else:\n return pd.DataFrame({'original': var, 'encoder': new_var})\n \ndef print_res(res, rows_per_level=2):\n out = pd.DataFrame(columns=res.columns)\n for lvl in res.original.unique():\n out = out.append(res[res.original==lvl].head(rows_per_level))\n return out\n```\n\n\n```python\ndownload_data = False\n```\n\n\n```python\nif download_data:\n url = \"http://mlr.cs.umass.edu/ml/machine-learning-databases/autos/imports-85.data\"\n r = requests.get(url)\n with open('imports-85.data', 'wb') as f:\n f.write(r.content)\n```\n\n\n```python\n# Define the headers since the data does not have any\nheaders = [\"symboling\", \"normalized_losses\", \"make\", \"fuel_type\", \"aspiration\",\n \"num_doors\", \"body_style\", \"drive_wheels\", \"engine_location\",\n \"wheel_base\", \"length\", \"width\", \"height\", \"curb_weight\",\n \"engine_type\", \"num_cylinders\", \"engine_size\", \"fuel_system\",\n \"bore\", \"stroke\", \"compression_ratio\", \"horsepower\", \"peak_rpm\",\n \"city_mpg\", \"highway_mpg\", \"price\"]\n# Read in the CSV file and convert \"?\" to NaN\ndf = pd.read_csv(\"imports-85.data\",\n header=None, names=headers, na_values=\"?\" )\n```\n\n\n```python\ndf.head()\n```\n\n\n\n\n\n \nHeader 1 \nHeader 2 \n\n \nrow 1, cell 1 \nrow 1, cell 2 \n\n \nrow 2, cell 1 \nrow 2, cell 2 \n\n \n
\n\n \n \n \n \n symboling \n normalized_losses \n make \n fuel_type \n aspiration \n num_doors \n body_style \n drive_wheels \n engine_location \n wheel_base \n ... \n engine_size \n fuel_system \n bore \n stroke \n compression_ratio \n horsepower \n peak_rpm \n city_mpg \n highway_mpg \n price \n \n \n 0 \n 3 \n NaN \n alfa-romero \n gas \n std \n two \n convertible \n rwd \n front \n 88.6 \n ... \n 130 \n mpfi \n 3.47 \n 2.68 \n 9.0 \n 111.0 \n 5000.0 \n 21 \n 27 \n 13495.0 \n \n \n 1 \n 3 \n NaN \n alfa-romero \n gas \n std \n two \n convertible \n rwd \n front \n 88.6 \n ... \n 130 \n mpfi \n 3.47 \n 2.68 \n 9.0 \n 111.0 \n 5000.0 \n 21 \n 27 \n 16500.0 \n \n \n 2 \n 1 \n NaN \n alfa-romero \n gas \n std \n two \n hatchback \n rwd \n front \n 94.5 \n ... \n 152 \n mpfi \n 2.68 \n 3.47 \n 9.0 \n 154.0 \n 5000.0 \n 19 \n 26 \n 16500.0 \n \n \n 3 \n 2 \n 164.0 \n audi \n gas \n std \n four \n sedan \n fwd \n front \n 99.8 \n ... \n 109 \n mpfi \n 3.19 \n 3.40 \n 10.0 \n 102.0 \n 5500.0 \n 24 \n 30 \n 13950.0 \n \n \n \n4 \n 2 \n 164.0 \n audi \n gas \n std \n four \n sedan \n 4wd \n front \n 99.4 \n ... \n 136 \n mpfi \n 3.19 \n 3.40 \n 8.0 \n 115.0 \n 5500.0 \n 18 \n 22 \n 17450.0 \n \n \n
\n\n \n \n \n \n original \n encoder \n \n \n 0 \n four \n 2 \n \n \n 1 \n four \n 2 \n \n \n 2 \n six \n 3 \n \n \n 12 \n six \n 3 \n \n \n 4 \n five \n 1 \n \n \n 5 \n five \n 1 \n \n \n 71 \n eight \n 0 \n \n \n 72 \n eight \n 0 \n \n \n 55 \n two \n 6 \n \n \n 56 \n two \n 6 \n \n \n 18 \n three \n 4 \n \n \n \n49 \n twelve \n 5 \n \n \n
\n\n \n \n \n \n original \n num_cylinders \n \n \n 0 \n four \n 3 \n \n \n 1 \n four \n 3 \n \n \n 2 \n six \n 5 \n \n \n 12 \n six \n 5 \n \n \n 4 \n five \n 4 \n \n \n 5 \n five \n 4 \n \n \n 71 \n eight \n 6 \n \n \n 72 \n eight \n 6 \n \n \n 55 \n two \n 1 \n \n \n 56 \n two \n 1 \n \n \n 18 \n three \n 2 \n \n \n \n49 \n twelve \n 7 \n \n \n
\n\n \n \n \n \n original \n drive_wheels_1 \n drive_wheels_2 \n drive_wheels_3 \n \n \n 3 \n fwd \n 0 \n 1 \n 0 \n \n \n 5 \n fwd \n 0 \n 1 \n 0 \n \n \n 0 \n rwd \n 1 \n 0 \n 0 \n \n \n 1 \n rwd \n 1 \n 0 \n 0 \n \n \n 4 \n 4wd \n 0 \n 0 \n 1 \n \n \n \n9 \n 4wd \n 0 \n 0 \n 1 \n \n \n
\n\n \n \n \n \n original \n drive_wheels_0 \n drive_wheels_1 \n drive_wheels_2 \n \n \n 3 \n fwd \n 0 \n 1 \n 0 \n \n \n 5 \n fwd \n 0 \n 1 \n 0 \n \n \n 0 \n rwd \n 0 \n 0 \n 1 \n \n \n 1 \n rwd \n 0 \n 0 \n 1 \n \n \n 4 \n 4wd \n 0 \n 1 \n 1 \n \n \n \n9 \n 4wd \n 0 \n 1 \n 1 \n \n \n
\n\n \n \n \n \n original \n make_0 \n make_1 \n make_2 \n make_3 \n make_4 \n make_5 \n \n \n 150 \n toyota \n 0 \n 1 \n 0 \n 1 \n 0 \n 0 \n \n \n 151 \n toyota \n 0 \n 1 \n 0 \n 1 \n 0 \n 0 \n \n \n 89 \n nissan \n 0 \n 0 \n 1 \n 1 \n 0 \n 1 \n \n \n 90 \n nissan \n 0 \n 0 \n 1 \n 1 \n 0 \n 1 \n \n \n 50 \n mazda \n 0 \n 0 \n 1 \n 0 \n 0 \n 1 \n \n \n 51 \n mazda \n 0 \n 0 \n 1 \n 0 \n 0 \n 1 \n \n \n 30 \n honda \n 0 \n 0 \n 0 \n 1 \n 1 \n 0 \n \n \n 31 \n honda \n 0 \n 0 \n 0 \n 1 \n 1 \n 0 \n \n \n 76 \n mitsubishi \n 0 \n 0 \n 1 \n 1 \n 0 \n 0 \n \n \n 77 \n mitsubishi \n 0 \n 0 \n 1 \n 1 \n 0 \n 0 \n \n \n 182 \n volkswagen \n 0 \n 1 \n 0 \n 1 \n 0 \n 1 \n \n \n 183 \n volkswagen \n 0 \n 1 \n 0 \n 1 \n 0 \n 1 \n \n \n 138 \n subaru \n 0 \n 1 \n 0 \n 0 \n 1 \n 1 \n \n \n 139 \n subaru \n 0 \n 1 \n 0 \n 0 \n 1 \n 1 \n \n \n 194 \n volvo \n 0 \n 1 \n 0 \n 1 \n 1 \n 0 \n \n \n 195 \n volvo \n 0 \n 1 \n 0 \n 1 \n 1 \n 0 \n \n \n 107 \n peugot \n 0 \n 0 \n 1 \n 1 \n 1 \n 0 \n \n \n 108 \n peugot \n 0 \n 0 \n 1 \n 1 \n 1 \n 0 \n \n \n 21 \n dodge \n 0 \n 0 \n 0 \n 1 \n 0 \n 1 \n \n \n 22 \n dodge \n 0 \n 0 \n 0 \n 1 \n 0 \n 1 \n \n \n 10 \n bmw \n 0 \n 0 \n 0 \n 0 \n 1 \n 1 \n \n \n 11 \n bmw \n 0 \n 0 \n 0 \n 0 \n 1 \n 1 \n \n \n 67 \n mercedes-benz \n 0 \n 0 \n 1 \n 0 \n 1 \n 0 \n \n \n 68 \n mercedes-benz \n 0 \n 0 \n 1 \n 0 \n 1 \n 0 \n \n \n 3 \n audi \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n \n \n 4 \n audi \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n \n \n 118 \n plymouth \n 0 \n 0 \n 1 \n 1 \n 1 \n 1 \n \n \n 119 \n plymouth \n 0 \n 0 \n 1 \n 1 \n 1 \n 1 \n \n \n 132 \n saab \n 0 \n 1 \n 0 \n 0 \n 1 \n 0 \n \n \n 133 \n saab \n 0 \n 1 \n 0 \n 0 \n 1 \n 0 \n \n \n 125 \n porsche \n 0 \n 1 \n 0 \n 0 \n 0 \n 0 \n \n \n 126 \n porsche \n 0 \n 1 \n 0 \n 0 \n 0 \n 0 \n \n \n 43 \n isuzu \n 0 \n 0 \n 0 \n 1 \n 1 \n 1 \n \n \n 44 \n isuzu \n 0 \n 0 \n 0 \n 1 \n 1 \n 1 \n \n \n 0 \n alfa-romero \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n \n \n 1 \n alfa-romero \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n \n \n 18 \n chevrolet \n 0 \n 0 \n 0 \n 1 \n 0 \n 0 \n \n \n 19 \n chevrolet \n 0 \n 0 \n 0 \n 1 \n 0 \n 0 \n \n \n 47 \n jaguar \n 0 \n 0 \n 1 \n 0 \n 0 \n 0 \n \n \n 48 \n jaguar \n 0 \n 0 \n 1 \n 0 \n 0 \n 0 \n \n \n 130 \n renault \n 0 \n 1 \n 0 \n 0 \n 0 \n 1 \n \n \n 131 \n renault \n 0 \n 1 \n 0 \n 0 \n 0 \n 1 \n \n \n \n75 \n mercury \n 0 \n 0 \n 1 \n 0 \n 1 \n 1 \n \n \n
\n\n \n \n \n \n original \n intercept \n drive_wheels_0 \n drive_wheels_1 \n \n \n 3 \n fwd \n 1 \n 0.666667 \n -0.333333 \n \n \n 5 \n fwd \n 1 \n 0.666667 \n -0.333333 \n \n \n 0 \n rwd \n 1 \n -0.333333 \n -0.333333 \n \n \n 1 \n rwd \n 1 \n -0.333333 \n -0.333333 \n \n \n 4 \n 4wd \n 1 \n -0.333333 \n 0.666667 \n \n \n \n9 \n 4wd \n 1 \n -0.333333 \n 0.666667 \n \n \n
\n\n \n \n \n \n original \n intercept \n drive_wheels_0 \n drive_wheels_1 \n \n \n 3 \n fwd \n 1 \n 0.0 \n 1.0 \n \n \n 5 \n fwd \n 1 \n 0.0 \n 1.0 \n \n \n 0 \n rwd \n 1 \n 1.0 \n 0.0 \n \n \n 1 \n rwd \n 1 \n 1.0 \n 0.0 \n \n \n 4 \n 4wd \n 1 \n -1.0 \n -1.0 \n \n \n \n9 \n 4wd \n 1 \n -1.0 \n -1.0 \n \n \n
\n\n \n \n \n \n original \n intercept \n num_cylinders_0 \n num_cylinders_1 \n num_cylinders_2 \n num_cylinders_3 \n num_cylinders_4 \n num_cylinders_5 \n \n \n 0 \n four \n 1 \n -1.889822e-01 \n -3.273268e-01 \n 4.082483e-01 \n 0.080582 \n -5.455447e-01 \n 0.493464 \n \n \n 1 \n four \n 1 \n -1.889822e-01 \n -3.273268e-01 \n 4.082483e-01 \n 0.080582 \n -5.455447e-01 \n 0.493464 \n \n \n 2 \n six \n 1 \n 1.889822e-01 \n -3.273268e-01 \n -4.082483e-01 \n 0.080582 \n 5.455447e-01 \n 0.493464 \n \n \n 12 \n six \n 1 \n 1.889822e-01 \n -3.273268e-01 \n -4.082483e-01 \n 0.080582 \n 5.455447e-01 \n 0.493464 \n \n \n 4 \n five \n 1 \n 1.617449e-17 \n -4.364358e-01 \n -1.109626e-16 \n 0.483494 \n -6.714569e-16 \n -0.657952 \n \n \n 5 \n five \n 1 \n 1.617449e-17 \n -4.364358e-01 \n -1.109626e-16 \n 0.483494 \n -6.714569e-16 \n -0.657952 \n \n \n 71 \n eight \n 1 \n 3.779645e-01 \n 1.195122e-17 \n -4.082483e-01 \n -0.564076 \n -4.364358e-01 \n -0.197386 \n \n \n 72 \n eight \n 1 \n 3.779645e-01 \n 1.195122e-17 \n -4.082483e-01 \n -0.564076 \n -4.364358e-01 \n -0.197386 \n \n \n 55 \n two \n 1 \n -5.669467e-01 \n 5.455447e-01 \n -4.082483e-01 \n 0.241747 \n -1.091089e-01 \n 0.032898 \n \n \n 56 \n two \n 1 \n -5.669467e-01 \n 5.455447e-01 \n -4.082483e-01 \n 0.241747 \n -1.091089e-01 \n 0.032898 \n \n \n 49 \n twelve \n 1 \n 5.669467e-01 \n 5.455447e-01 \n 4.082483e-01 \n 0.241747 \n 1.091089e-01 \n 0.032898 \n \n \n \n18 \n three \n 1 \n -3.779645e-01 \n 9.521795e-17 \n 4.082483e-01 \n -0.564076 \n 4.364358e-01 \n -0.197386 \n \n \n
\n\n \n \n \n \n original \n intercept \n body_style_0 \n body_style_1 \n body_style_2 \n body_style_3 \n \n \n 3 \n sedan \n 1 \n 0.0 \n 2.0 \n -1.0 \n -1.0 \n \n \n 4 \n sedan \n 1 \n 0.0 \n 2.0 \n -1.0 \n -1.0 \n \n \n 2 \n hatchback \n 1 \n 1.0 \n -1.0 \n -1.0 \n -1.0 \n \n \n 9 \n hatchback \n 1 \n 1.0 \n -1.0 \n -1.0 \n -1.0 \n \n \n 7 \n wagon \n 1 \n 0.0 \n 0.0 \n 3.0 \n -1.0 \n \n \n 28 \n wagon \n 1 \n 0.0 \n 0.0 \n 3.0 \n -1.0 \n \n \n 69 \n hardtop \n 1 \n 0.0 \n 0.0 \n 0.0 \n 4.0 \n \n \n 74 \n hardtop \n 1 \n 0.0 \n 0.0 \n 0.0 \n 4.0 \n \n \n 0 \n convertible \n 1 \n -1.0 \n -1.0 \n -1.0 \n -1.0 \n \n \n \n1 \n convertible \n 1 \n -1.0 \n -1.0 \n -1.0 \n -1.0 \n \n \n
\n\n \n \n \n \n original \n intercept \n body_style_0 \n body_style_1 \n body_style_2 \n body_style_3 \n \n \n 0 \n convertible \n 1 \n -0.8 \n -0.6 \n -0.4 \n -0.2 \n \n \n 1 \n convertible \n 1 \n -0.8 \n -0.6 \n -0.4 \n -0.2 \n \n \n 2 \n hatchback \n 1 \n 0.2 \n -0.6 \n -0.4 \n -0.2 \n \n \n 9 \n hatchback \n 1 \n 0.2 \n -0.6 \n -0.4 \n -0.2 \n \n \n 3 \n sedan \n 1 \n 0.2 \n 0.4 \n -0.4 \n -0.2 \n \n \n 4 \n sedan \n 1 \n 0.2 \n 0.4 \n -0.4 \n -0.2 \n \n \n 7 \n wagon \n 1 \n 0.2 \n 0.4 \n 0.6 \n -0.2 \n \n \n 28 \n wagon \n 1 \n 0.2 \n 0.4 \n 0.6 \n -0.2 \n \n \n 69 \n hardtop \n 1 \n 0.2 \n 0.4 \n 0.6 \n 0.8 \n \n \n \n74 \n hardtop \n 1 \n 0.2 \n 0.4 \n 0.6 \n 0.8 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 0.585366 \n \n \n 5 \n fwd \n 0.585366 \n \n \n 0 \n rwd \n 0.370732 \n \n \n 1 \n rwd \n 0.370732 \n \n \n 4 \n 4wd \n 0.043902 \n \n \n \n9 \n 4wd \n 0.043902 \n \n \n
\n\n \n \n \n \n original \n col_0 \n col_1 \n col_2 \n col_3 \n col_4 \n col_5 \n col_6 \n col_7 \n \n \n 0 \n rwd \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 0 \n \n \n 1 \n rwd \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 0 \n \n \n 3 \n fwd \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 0 \n 0 \n \n \n 5 \n fwd \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n 0 \n 0 \n \n \n 4 \n 4wd \n 0 \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n \n \n \n9 \n 4wd \n 0 \n 0 \n 0 \n 0 \n 0 \n 0 \n 1 \n 0 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 9244.779661 \n \n \n 5 \n fwd \n 9244.779661 \n \n \n 0 \n rwd \n 19757.613333 \n \n \n 1 \n rwd \n 19757.613333 \n \n \n 4 \n 4wd \n 10243.702296 \n \n \n \n9 \n 4wd \n 10243.702296 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 9244.779661 \n \n \n 5 \n fwd \n 9244.779661 \n \n \n 0 \n rwd \n 19757.613333 \n \n \n 1 \n rwd \n 19757.613333 \n \n \n 4 \n 4wd \n 10241.000000 \n \n \n \n9 \n 4wd \n 10241.000000 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 9278.076717 \n \n \n 5 \n fwd \n 9278.076717 \n \n \n 0 \n rwd \n 19671.422755 \n \n \n 1 \n rwd \n 19671.422755 \n \n \n 4 \n 4wd \n 10570.569928 \n \n \n \n9 \n 4wd \n 10570.569928 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 9244.779661 \n \n \n 5 \n fwd \n 9244.779661 \n \n \n 0 \n rwd \n 19757.613333 \n \n \n 1 \n rwd \n 19757.613333 \n \n \n 4 \n 4wd \n 10241.000000 \n \n \n \n9 \n 4wd \n 10241.000000 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 9278.076717 \n \n \n 5 \n fwd \n 9278.076717 \n \n \n 0 \n rwd \n 19671.422755 \n \n \n 1 \n rwd \n 19671.422755 \n \n \n 4 \n 4wd \n 10570.569928 \n \n \n \n9 \n 4wd \n 10570.569928 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 0.275848 \n \n \n 5 \n fwd \n 0.275848 \n \n \n 0 \n rwd \n -0.435318 \n \n \n 1 \n rwd \n -0.435318 \n \n \n 4 \n 4wd \n 0.162519 \n \n \n \n9 \n 4wd \n 0.162519 \n \n \n
\n\n \n \n \n \n original \n drive_wheels \n \n \n 3 \n fwd \n 0.287682 \n \n \n 5 \n fwd \n 0.287682 \n \n \n 0 \n rwd \n -0.448132 \n \n \n 1 \n rwd \n -0.448132 \n \n \n 4 \n 4wd \n inf \n \n \n \n9 \n 4wd \n inf \n Table of Contents
\n\n\n# Question\n**Question 1.1** Write a Python Program(with class concepts) to find the area of the triangle using the below formula.
\n\n`area = (s*(s-a)*(s-b)*(s-c)) ** 0.5`
\n\nFunction to take the length of the sides of triangle from user should be defined in the parent class and function to calculate the area should be defined in subclass.\n\n**BreakDown points**
\n`Class Parent : Should Read inputs from User fr the sides of triangle`
\n`Class Child : Should Calculate the Area Of Triangle with Variables from parent`
\n\n**Heron's Formula**\n\\begin{align}\ns = \\frac{a + b + c}{2}\n\\end{align}\n
\n\\begin{align}\nArea Of Triangle = \\sqrt{(s*(s-a)*(s-b)*(s-c))}\n\\end{align}\n\n## Answer\n\n\n```python\n# Parent Class : Will get the input from User and display\nclass LengthOfTheSides():\n def __init__(self):\n print('Please provide length of the sides of triangle : \\n')\n self.a = float(input('side1 : '))\n self.b = float(input('side2 : '))\n self.c = float(input('side3 : '))\n \n def __repr__(self):\n return 'Provided Values are ...\\nside1 = {}, side2 = {}, side3 = {}\\n\\n'.format(str(self.a),str(self.b), str(self.c))\n\n# Child Class : Will Calculate the Area Of Triangle\nclass Area(LengthOfTheSides):\n def __init__(self):\n LengthOfTheSides.__init__(self)\n \n def AreaOfTriangle(self):\n s, a, b, c = (self.a + self.b + self.c)/2, self.a, self.b, self.c\n return (s*(s-a)*(s-b)*(s-c)) ** 0.5\n\nAreaOfTriangle = Area()\nprint('\\nArea Of Triangle : {}'.format(AreaOfTriangle.AreaOfTriangle()))\n```\n\n Please provide length of the sides of triangle : \n \n side1 : 5\n side2 : 4\n side3 : 3\n \n Area Of Triangle : 6.0\n\n\n# Question\n\n**Question 1.2** Write a function filter_long_words() that takes a list of words and an integer n and returns the list of words that are longer than n.\n\n## Answer\n\n\n```python\ndef filter_long_words(words_to_check, max_length):\n # Check Provided Arg[0] is List\n if not isinstance(words_to_check, list):\n raise Exception('Please enter arg[0] as list of words')\n # Check Provided Arg[1] is int\n if not isinstance(max_length, int):\n raise Exception('Please enter arg[1] as int')\n \n return [i for i in words_to_check if len(i)>max_length]\n```\n\n\n```python\n# Correct Arguments Passed\n\nfilter_long_words(['Vignesh', 'Vicky'], 5)\n```\n\n\n\n\n ['Vignesh']\n\n\n\n\n```python\n# Arg[0] is String \n\nfilter_long_words('Vignesh', 5)\n```\n\n\n```python\n# Arg[1] is String \n\nfilter_long_words(['Vignesh', 'Vicky'], \"5\")\n```\n\n# Question\n\n**Question 2.1** Write a Python program using function concept that maps list of words into a list of integers representing the lengths of the corresponding words.\n\n**Hint:** If a list [ ab,cde,erty] is passed on to the python function output should come as [2,3,4]. Here 2,3 and 4 are the lengths of the words in the list.\n\n## Answer\n\n\n```python\ndef words_to_int(words_to_check):\n # Check Provided Arg[0] is List\n if not isinstance(words_to_check, list):\n raise Exception('Please enter arg[0] as list of words')\n \n return [len(i) for i in words_to_check]\n```\n\n\n```python\nwords_to_int(['Vignesh', 'Vicky'])\n```\n\n\n\n\n [7, 5]\n\n\n\n# Question\n\n**Question 2.2** Write a Python function which takes a character (i.e. a string of length 1) and returns True if it is a vowel, False otherwise.\n\n## Answer\n\n\n```python\ndef check_vowels(char_to_check):\n vowels = ('a', 'e', 'i', 'o', 'u')\n \n # Check Provided Arg[0] is a Single Charecter String\n if isinstance(char_to_check, str) and len(char_to_check) == 1:\n if char_to_check.lower() in vowels:\n return True\n else:\n return False\n else:\n raise Exception('Please enter arg[0] as a Single Charecter String')\n```\n\n\n```python\ncheck_vowels('V')\n```\n\n\n\n\n False\n\n\n\n\n```python\ncheck_vowels('I')\n```\n\n\n\n\n True\n\n\n", "meta": {"hexsha": "790c1ada8d04f8daf20879ad50f848003c29b2e8", "size": 15478, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "Assignments/Basic-Python-Assignment-4-OOPS.ipynb", "max_stars_repo_name": "vigneshpalanivelr/MeachineLearningAI", "max_stars_repo_head_hexsha": "16741f08b8846fd27c319aff24d7e043acb843f3", "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": "Assignments/Basic-Python-Assignment-4-OOPS.ipynb", "max_issues_repo_name": "vigneshpalanivelr/MeachineLearningAI", "max_issues_repo_head_hexsha": "16741f08b8846fd27c319aff24d7e043acb843f3", "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/Basic-Python-Assignment-4-OOPS.ipynb", "max_forks_repo_name": "vigneshpalanivelr/MeachineLearningAI", "max_forks_repo_head_hexsha": "16741f08b8846fd27c319aff24d7e043acb843f3", "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": 35.9953488372, "max_line_length": 1352, "alphanum_fraction": 0.5742343972, "converted": true, "num_tokens": 1489, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.47268346176374815, "lm_q2_score": 0.1422318931919251, "lm_q1q2_score": 0.06723066364717084}}
{"text": "# pAPRika tutorial 5 - APR/Amber with Plumed restraints\n\nIn this tutorial, we will perform APR calculations for the butane (BUT)--cucurbit[6]uril (CB6) host-guest system. This is a repeat of [Tutorial 1](01-tutorial-cb6-but.ipynb) using `Plumed`-based restraints and the `AMBER` MD engine. `Plumed` is a plugin for MD codes that can analyze trajectories and perform free-energy calculations on collective variables. It is a versatile plugin that can interface with a number of MD engines. Here, we will go through the process of converting APR restraints constructed with pAPRika to a `Plumed` file and run a short calculation with `sander`.\n\n## Initialize\n\n### Before you start\n\nWe will run the simulations in this tutorial using `sander` (*Ambertools*) and `Plumed`. Both of these should be installed in your `conda` environment if you installed *pAPRika* though the `conda` route. However, for `Plumed` to work with `sander` we first need to make sure the `PLUMED_KERNEL` environment variable is loaded (the library is called `libplumedKernel.so`). *pAPRika* should load the `Plumed` kernel automatically but let's make sure it is loaded and run the cell below.\n\n\n```python\nimport os\n'PLUMED_KERNEL' in os.environ.keys()\n```\n\n\n\n\n False\n\n\n\nIf it does not exists we will load the environment in this Jupyter Notebook. Since `Plumed` is installed through `conda` the kernel will be located in your conda environment library folder. If you are running this on a Mac replace the kernel library in the cell below to `libplumedKernel.dylib`. If you compiled `Plumed` yourself and then you will need to change the path below.\n\n\n```python\nos.environ['PLUMED_KERNEL'] = f\"{os.environ['CONDA_PREFIX']}/lib/libplumedKernel.so\"\n```\n\nFor running `Plumed` with Amber outside of this notebook it might be better to export the `PLUMED_KERNEL` variable into your `.bashrc` file.\n\n**Note:** we can run `Plumed` with `AMBER` versions 18 and 20, but version 18 requires you to patch the source code first and recompile. Older versions of Amber are not supported. See the `Plumed` documentation for more details https://www.plumed.org/doc-v2.6/user-doc/html/index.html.\n\n🔵 Since we have a prepared the host-guest-dummy setup from the first tutorial, we will skip the initial tleap steps and go right into initializing the restraints.\n\n### Define names\nWe will store the files created in this tutorial in a folder called `plumed` so we don't mix files with the previous tutorial.\n\n\n```python\nbase_name = \"cb6-but-dum\"\nwork_dir = \"plumed\"\ncomplex_dir = \"complex\"\n```\n\n## Configure APR Restraints\n\n### Define anchor atoms\nSee [tutorial 1](01-tutorial-cb6-but.ipynb) for the choice of selection\n\n\n```python\n# Guest atoms\nG1 = \":BUT@C\"\nG2 = \":BUT@C3\"\n\n# Host atoms\nH1 = \":CB6@C\"\nH2 = \":CB6@C31\"\nH3 = \":CB6@C18\"\n\n# Dummy atoms\nD1 = \":DM1\"\nD2 = \":DM2\"\nD3 = \":DM3\"\n```\n\n### Determine the number of windows\nBefore we add the restraints, it is helpful to set the $\\lambda$ fractions that control the strength of the force constants during attach and release, and to define the distances for the pulling phase.\n\nThe attach fractions go from 0 to 1 and we place more points at the bottom of the range to sample the curvature of $dU/d \\lambda$. Next, we generally apply a distance restraint until the guest is ~18 Angstroms away from the host, in increments of 0.4 Angstroms. This distance should be at least twice the Lennard-Jones cutoff in the system. These values have worked well for us, but this is one aspect that should be carefully checked for new systems.\n\n\n```python\nimport numpy as np\n```\n\n\n```python\nattach_string = \"0.00 0.40 0.80 1.60 2.40 4.00 5.50 8.65 11.80 18.10 24.40 37.00 49.60 74.80 100.00\"\nattach_fractions = [float(i) / 100 for i in attach_string.split()]\n\ninitial_distance = 6.0\npull_distances = np.arange(0.0 + initial_distance, 18.0 + initial_distance, 1.0)\n\nrelease_fractions = []\n\nwindows = [len(attach_fractions), len(pull_distances), len(release_fractions)]\nprint(f\"There are {windows} windows in this attach-pull-release calculation.\")\n```\n\n There are [15, 18, 0] windows in this attach-pull-release calculation.\n\n\n### Load structure\n\n\n```python\nimport parmed as pmd\n```\n\n* Load complex structure\n\n\n```python\nstructure = pmd.load_file(\n os.path.join(complex_dir, f\"{base_name}.prmtop\"),\n os.path.join(complex_dir, f\"{base_name}.rst7\"),\n structure = True,\n) \n```\n\n### Host Static Restraints\nSee [tutorial 1](01-tutorial-cb6-but.ipynb#host_static) for an explanation of the static restraints\n\n\n```python\nimport paprika.restraints as restraints\n```\n\n\n```python\nstatic_restraints = []\n```\n\n\n```python\nr = restraints.static_DAT_restraint(restraint_mask_list = [D1, H1],\n num_window_list = windows,\n ref_structure = structure,\n force_constant = 5.0,\n amber_index=True)\n\nstatic_restraints.append(r)\n```\n\n\n```python\nr = restraints.static_DAT_restraint(restraint_mask_list = [D2, D1, H1],\n num_window_list = windows,\n ref_structure = structure,\n force_constant = 100.0,\n amber_index=True)\n\nstatic_restraints.append(r)\n```\n\n\n```python\nr = restraints.static_DAT_restraint(restraint_mask_list = [D3, D2, D1, H1],\n num_window_list = windows,\n ref_structure = structure,\n force_constant = 100.0,\n amber_index=True)\n\nstatic_restraints.append(r)\n```\n\n\n```python\nr = restraints.static_DAT_restraint(restraint_mask_list = [D1, H1, H2],\n num_window_list = windows,\n ref_structure = structure,\n force_constant = 100.0,\n amber_index=True)\n\nstatic_restraints.append(r)\n```\n\n\n```python\nr = restraints.static_DAT_restraint(restraint_mask_list = [D2, D1, H1, H2],\n num_window_list = windows,\n ref_structure = structure,\n force_constant = 100.0,\n amber_index=True)\n\nstatic_restraints.append(r)\n```\n\n\n```python\nr = restraints.static_DAT_restraint(restraint_mask_list = [D1, H1, H2, H3],\n num_window_list = windows,\n ref_structure = structure,\n force_constant = 100.0,\n amber_index=True)\n\nstatic_restraints.append(r)\n```\n\n### Guest translational and rotational restraints\nSee [tutorial 1](01-tutorial-cb6-but.ipynb#guest) for an explanation of the guest restraints\n\n\n```python\nguest_restraints = []\n```\n\n\n```python\nr = restraints.DAT_restraint()\nr.mask1 = D1\nr.mask2 = G1\nr.topology = structure\nr.auto_apr = True\nr.continuous_apr = True\nr.amber_index = True\n\nr.attach[\"target\"] = pull_distances[0] # Angstroms\nr.attach[\"fraction_list\"] = attach_fractions\nr.attach[\"fc_final\"] = 5.0 # kcal/mol/Angstroms**2\n\nr.pull[\"target_final\"] = 24.0 # Angstroms\nr.pull[\"num_windows\"] = windows[1]\n\nr.initialize()\nguest_restraints.append(r)\n```\n\n\n```python\nr = restraints.DAT_restraint()\nr.mask1 = D2\nr.mask2 = D1\nr.mask3 = G1\nr.topology = structure\nr.auto_apr = True\nr.continuous_apr = True\nr.amber_index = True\n\nr.attach[\"target\"] = 180.0 # Degrees\nr.attach[\"fraction_list\"] = attach_fractions\nr.attach[\"fc_final\"] = 100.0 # kcal/mol/radian**2\n\nr.pull[\"target_final\"] = 180.0 # Degrees\nr.pull[\"num_windows\"] = windows[1]\n\nr.initialize()\nguest_restraints.append(r)\n```\n\n\n```python\nr = restraints.DAT_restraint()\nr.mask1 = D1\nr.mask2 = G1\nr.mask3 = G2\nr.topology = structure\nr.auto_apr = True\nr.continuous_apr = True\nr.amber_index = True\n\nr.attach[\"target\"] = 180.0 # Degrees\nr.attach[\"fraction_list\"] = attach_fractions\nr.attach[\"fc_final\"] = 100.0 # kcal/mol/radian**2\n\nr.pull[\"target_final\"] = 180.0 # Degrees\nr.pull[\"num_windows\"] = windows[1]\n\nr.initialize()\nguest_restraints.append(r)\n```\n\n### Create APR windows\nWe use the guest restraints to create a list of windows with the appropriate names and then create the directories.\n\n\n```python\nfrom paprika.restraints.restraints import create_window_list\n```\n\n\n```python\nwindow_list = create_window_list(guest_restraints)\n```\n\n\n```python\nif not os.path.isdir(work_dir):\n os.makedirs(work_dir)\n \nfor window in window_list:\n folder = os.path.join(work_dir, window)\n if not os.path.isdir(folder):\n os.makedirs(os.path.join(work_dir, window))\n```\n\n### Write APR restraints to Plumed format\nIn this section we create an instance of `Plumed()` from `paprika.restraints.plumed`, which is a class to generate the `Plumed` restraint files. We need to specify the list of restraints used throughout the APR calculations and the corresponding windows list. In this tutorial we will print the **host static** restraints and the **guest** restraints. The `Plumed` class includes a method to add restraints to dummy atoms (`add_dummy_atoms_to_file`) but we will not do that here. Instead we will use the built-in position restraints feature in Amber (see [Simulation](#simulate) section below).\n\n**Note**: be careful when specifiying the force constants in `DAT_restraints`. We follow the Amber (and CHARMM) convention where the force constant is already multiplied by a factor of 1/2 but `Plumed` requires the user to specify the force constant without this factor, i.e.\n\n$$\n\\begin{align}\nU_{amber} &= K_{amber} (r-r_{0})^2 \\\\\nU_{plumed} &= \\frac{1}{2} k_{plumed} (r - r_{0})^2 \n\\end{align}\n$$\n\nthus $k_{plumed} = 2 \\times K_{amber}$. If Amber force constants was used in generating the `DAT_restraints` (the case in this tutorial) we need to set the variable `uses_legacy_k` to `True` (this is on by default).\n\n\n```python\nfrom paprika.restraints.plumed import Plumed\n```\n\n\n```python\nrestraints_list = (static_restraints + guest_restraints)\n\nplumed = Plumed()\nplumed.file_name = 'plumed.dat'\nplumed.path = work_dir\nplumed.window_list = window_list\nplumed.restraint_list = restraints_list\nplumed.uses_legacy_k = True\n\nplumed.dump_to_file()\n```\n\n## Prepare host-guest system\n\n### Translate guest molecule\nFor the attach windows, we will use the initial, bound coordinates for the host-guest complex. Only the force constants change during this phase, so a single set of coordinates is sufficient. For the pull windows, we will translate the guest to the target value of the restraint before solvation, and for the release windows, we will use the coordinates from the final pull window.\n\n\n```python\nimport shutil\n```\n\n\n```python\nfor window in window_list:\n if window[0] == \"a\":\n shutil.copy(os.path.join(complex_dir, f\"{base_name}.prmtop\"),\n os.path.join(work_dir, window, f\"{base_name}.prmtop\"))\n shutil.copy(os.path.join(complex_dir, f\"{base_name}.rst7\"),\n os.path.join(work_dir, window, f\"{base_name}.rst7\"))\n\n elif window[0] == \"p\":\n structure = pmd.load_file(\n os.path.join(complex_dir, f\"{base_name}.prmtop\"), \n os.path.join(complex_dir, f\"{base_name}.rst7\"), \n structure = True\n )\n target_difference = guest_restraints[0].phase['pull']['targets'][int(window[1:])] -\\\n guest_restraints[0].pull['target_initial']\n print(f\"In window {window} we will translate the guest {target_difference.magnitude:0.1f}.\")\n \n for atom in structure.atoms:\n if atom.residue.name == \"BUT\":\n atom.xz += target_difference.magnitude\n \n structure.save(os.path.join(work_dir, window, f\"{base_name}.prmtop\"), overwrite=True)\n structure.save(os.path.join(work_dir, window, f\"{base_name}.rst7\"), overwrite=True)\n```\n\n In window p000 we will translate the guest 0.0 Angstroms.\n In window p001 we will translate the guest 1.1 Angstroms.\n In window p002 we will translate the guest 2.1 Angstroms.\n In window p003 we will translate the guest 3.2 Angstroms.\n In window p004 we will translate the guest 4.2 Angstroms.\n In window p005 we will translate the guest 5.3 Angstroms.\n In window p006 we will translate the guest 6.4 Angstroms.\n In window p007 we will translate the guest 7.4 Angstroms.\n In window p008 we will translate the guest 8.5 Angstroms.\n In window p009 we will translate the guest 9.5 Angstroms.\n In window p010 we will translate the guest 10.6 Angstroms.\n In window p011 we will translate the guest 11.6 Angstroms.\n In window p012 we will translate the guest 12.7 Angstroms.\n In window p013 we will translate the guest 13.8 Angstroms.\n In window p014 we will translate the guest 14.8 Angstroms.\n In window p015 we will translate the guest 15.9 Angstroms.\n In window p016 we will translate the guest 16.9 Angstroms.\n In window p017 we will translate the guest 18.0 Angstroms.\n\n\n## Simulation\n\nSince we are going to run an implicit solvent simulation, we have everything ready to go. **pAPRika** has an `AMBER` module that can help setting default parameters for the simulation. There are some high level options that we set directly, like `simulation.path`, and then we call the function `config_gb_min()` to setup reasonable default simulation parameters for a minimization in the Generalized-Born ensemble. After that, we directly modify the simulation `cntrl` section to apply the positional restraints on the dummy atoms. \n\nWe will run the simulations with `sander` but it is also possible and faster to run this with `pmemd` or `pmemd.cuda` if you have them installed.\n\n**Note**: The difference here compared to [Tutorial 1](01-tutorial-cb6-but.ipynb#simulate) is that instead of specifying a `simulation.restraint_file` we will specify `simulation.plumed_file`.\n\n**Note**: as explained at the [start](#start) of this tutorial, make sure that the `PLUMED_KERNEL` environment variable is set otherwise the simulation will fail to run.\n\n\n```python\nfrom paprika.simulate import AMBER\n```\n\nInitialize logger\n\n\n```python\nimport logging\nfrom importlib import reload\nreload(logging)\n\nlogger = logging.getLogger()\nlogging.basicConfig(\n format='%(asctime)s %(message)s',\n datefmt='%Y-%m-%d %I:%M:%S %p',\n level=logging.INFO\n)\n```\n\n### Energy Minimization\nRun a quick minimization in every window. Note that we need to specify `simulation.cntrl[\"ntr\"] = 1` to enable the positional restraints on the dummy atoms.\n\n\n```python\nfor window in window_list:\n simulation = AMBER()\n simulation.executable = \"sander\"\n\n simulation.path = f\"{work_dir}/{window}/\"\n simulation.prefix = \"minimize\"\n\n simulation.topology = \"cb6-but-dum.prmtop\"\n simulation.coordinates = \"cb6-but-dum.rst7\"\n simulation.ref = \"cb6-but-dum.rst7\"\n simulation.plumed_file = \"plumed.dat\"\n\n simulation.config_gb_min()\n simulation.cntrl[\"ntr\"] = 1\n simulation.cntrl[\"restraint_wt\"] = 50.0\n simulation.cntrl[\"restraintmask\"] = \"'@DUM'\"\n\n logger.info(f\"Running minimization in window {window}...\")\n simulation.run(overwrite=True)\n```\n\n 2020-10-01 11:18:20 AM Running minimization in window a000...\n 2020-10-01 11:18:31 AM Running minimization in window a001...\n 2020-10-01 11:18:42 AM Running minimization in window a002...\n 2020-10-01 11:18:54 AM Running minimization in window a003...\n 2020-10-01 11:19:05 AM Running minimization in window a004...\n 2020-10-01 11:19:17 AM Running minimization in window a005...\n 2020-10-01 11:19:28 AM Running minimization in window a006...\n 2020-10-01 11:19:42 AM Running minimization in window a007...\n 2020-10-01 11:19:54 AM Running minimization in window a008...\n 2020-10-01 11:20:06 AM Running minimization in window a009...\n 2020-10-01 11:20:18 AM Running minimization in window a010...\n 2020-10-01 11:20:30 AM Running minimization in window a011...\n 2020-10-01 11:20:42 AM Running minimization in window a012...\n 2020-10-01 11:20:53 AM Running minimization in window a013...\n 2020-10-01 11:21:04 AM Running minimization in window p000...\n 2020-10-01 11:21:14 AM Running minimization in window p001...\n 2020-10-01 11:21:26 AM Running minimization in window p002...\n 2020-10-01 11:21:38 AM Running minimization in window p003...\n 2020-10-01 11:21:50 AM Running minimization in window p004...\n 2020-10-01 11:22:01 AM Running minimization in window p005...\n 2020-10-01 11:22:15 AM Running minimization in window p006...\n 2020-10-01 11:22:28 AM Running minimization in window p007...\n 2020-10-01 11:22:40 AM Running minimization in window p008...\n 2020-10-01 11:22:54 AM Running minimization in window p009...\n 2020-10-01 11:23:06 AM Running minimization in window p010...\n 2020-10-01 11:23:19 AM Running minimization in window p011...\n 2020-10-01 11:23:31 AM Running minimization in window p012...\n 2020-10-01 11:23:44 AM Running minimization in window p013...\n 2020-10-01 11:23:55 AM Running minimization in window p014...\n 2020-10-01 11:24:07 AM Running minimization in window p015...\n 2020-10-01 11:24:19 AM Running minimization in window p016...\n 2020-10-01 11:24:30 AM Running minimization in window p017...\n\n\n### Production Run\nHere we will skip the equilibration step and go straight to production!\n\n\n```python\nfor window in window_list:\n simulation = AMBER()\n simulation.executable = \"sander\"\n \n simulation.path = f\"{work_dir}/{window}/\"\n simulation.prefix = \"production\"\n\n simulation.topology = \"cb6-but-dum.prmtop\"\n simulation.coordinates = \"minimize.rst7\"\n simulation.ref = \"cb6-but-dum.rst7\"\n simulation.plumed_file = \"plumed.dat\"\n\n simulation.config_gb_md()\n simulation.cntrl[\"ntr\"] = 1\n simulation.cntrl[\"restraint_wt\"] = 50.0\n simulation.cntrl[\"restraintmask\"] = \"'@DUM'\"\n \n logger.info(f\"Running production in window {window}...\")\n simulation.run(overwrite=True)\n```\n\n 2020-10-01 11:12:15 AM Running production in window a000...\n 2020-10-01 11:12:25 AM Running production in window a001...\n 2020-10-01 11:12:34 AM Running production in window a002...\n 2020-10-01 11:12:44 AM Running production in window a003...\n 2020-10-01 11:12:55 AM Running production in window a004...\n 2020-10-01 11:13:06 AM Running production in window a005...\n 2020-10-01 11:13:19 AM Running production in window a006...\n 2020-10-01 11:13:29 AM Running production in window a007...\n 2020-10-01 11:13:39 AM Running production in window a008...\n 2020-10-01 11:13:49 AM Running production in window a009...\n 2020-10-01 11:13:59 AM Running production in window a010...\n 2020-10-01 11:14:10 AM Running production in window a011...\n 2020-10-01 11:14:19 AM Running production in window a012...\n 2020-10-01 11:14:29 AM Running production in window a013...\n 2020-10-01 11:14:39 AM Running production in window p000...\n 2020-10-01 11:14:49 AM Running production in window p001...\n 2020-10-01 11:14:59 AM Running production in window p002...\n 2020-10-01 11:15:10 AM Running production in window p003...\n 2020-10-01 11:15:21 AM Running production in window p004...\n 2020-10-01 11:15:33 AM Running production in window p005...\n 2020-10-01 11:15:43 AM Running production in window p006...\n 2020-10-01 11:15:55 AM Running production in window p007...\n 2020-10-01 11:16:05 AM Running production in window p008...\n 2020-10-01 11:16:18 AM Running production in window p009...\n 2020-10-01 11:16:31 AM Running production in window p010...\n 2020-10-01 11:16:45 AM Running production in window p011...\n 2020-10-01 11:16:56 AM Running production in window p012...\n 2020-10-01 11:17:05 AM Running production in window p013...\n 2020-10-01 11:17:16 AM Running production in window p014...\n 2020-10-01 11:17:26 AM Running production in window p015...\n 2020-10-01 11:17:37 AM Running production in window p016...\n 2020-10-01 11:17:49 AM Running production in window p017...\n\n\n## Analysis\n\nOnce the simulation is completed, we can using the `analysis` module to determine the binding free energy. We supply the location of the parameter information, a string or list for the file names (wildcards supported), the location of the windows, and the restraints on the guest.\n\nIn this example, we use the method `ti-block` which determines the free energy using **t**hermodynamic **i**integration and then estimates the standard error of the mean at each data point using blocking analysis. Bootstrapping it used to determine the uncertainty of the full thermodynamic integral for each phase.\n\nAfter running `compute_free_energy()`, a dictionary called `results` will be populated, that contains the free energy and SEM for each phase of the simulation.\n\n\n```python\nimport paprika.analysis as analysis\n```\n\n\n```python\nfree_energy = analysis.fe_calc()\nfree_energy.topology = \"cb6-but-dum.prmtop\"\nfree_energy.trajectory = 'production*.nc'\nfree_energy.path = work_dir\nfree_energy.restraint_list = guest_restraints\nfree_energy.collect_data()\nfree_energy.methods = ['ti-block']\nfree_energy.ti_matrix = \"full\"\nfree_energy.bootcycles = 1000\nfree_energy.compute_free_energy()\n```\n\nWe also need to calculate the free-energy cost of releasing the restraints on the guest molecule.\n\n\n```python\nfree_energy.compute_ref_state_work([\n guest_restraints[0], guest_restraints[1], None, None,\n guest_restraints[2], None\n])\n```\n\nThen we add the free-energies together and combine the uncertainties to get the binding-free energy\n\n\n```python\nbinding_affinity = -1 * (\n free_energy.results[\"attach\"][\"ti-block\"][\"fe\"] + \\\n free_energy.results[\"pull\"][\"ti-block\"][\"fe\"] + \\\n free_energy.results[\"ref_state_work\"]\n)\n\nsem = np.sqrt(\n free_energy.results[\"attach\"][\"ti-block\"][\"sem\"]**2 + \\\n free_energy.results[\"pull\"][\"ti-block\"][\"sem\"]**2\n)\n```\n\n\n```python\nprint(f\"The binding affinity of butane to cucurbit[6]uril = {binding_affinity.magnitude:0.2f} +/- {sem.magnitude:0.2f} kcal/mol\")\n```\n\n The binding affinity of butane to cucurbit[6]uril = -7.24 +/- 6.52 kcal/mol\n\n", "meta": {"hexsha": "7d061608ed020055934d24cbeb8e4d8a87af6768", "size": 33840, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "docs/tutorials/05-tutorial-cb6-but-plumed.ipynb", "max_stars_repo_name": "jaketanderson/pAPRika", "max_stars_repo_head_hexsha": "5376f44ee1f7a0785f712b3b6c7bfa4c698ca65e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 16, "max_stars_repo_stars_event_min_datetime": "2017-04-19T23:46:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-05T19:47:02.000Z", "max_issues_repo_path": "docs/tutorials/05-tutorial-cb6-but-plumed.ipynb", "max_issues_repo_name": "jaketanderson/pAPRika", "max_issues_repo_head_hexsha": "5376f44ee1f7a0785f712b3b6c7bfa4c698ca65e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 154, "max_issues_repo_issues_event_min_datetime": "2017-04-20T16:05:26.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-24T21:07:18.000Z", "max_forks_repo_path": "docs/tutorials/05-tutorial-cb6-but-plumed.ipynb", "max_forks_repo_name": "jaketanderson/pAPRika", "max_forks_repo_head_hexsha": "5376f44ee1f7a0785f712b3b6c7bfa4c698ca65e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 12, "max_forks_repo_forks_event_min_datetime": "2017-07-06T07:55:31.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-12T05:05:44.000Z", "avg_line_length": 33.3070866142, "max_line_length": 603, "alphanum_fraction": 0.5667553191, "converted": true, "num_tokens": 6061, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.40733340004593027, "lm_q2_score": 0.16451645880021026, "lm_q1q2_score": 0.06701304852660585}}
{"text": "# Markdown 與 LaTeX簡介\n\n每個範例內容將範例語法與輸出分為不同的 Cell 放置，雙擊 Cell 也可以查看原始碼，進行進一步的研究與實驗。\n\n## 1. Markdown 主要語法\n\n### 1.1 段落和斷行\n\n_範例語法：_\n```\n前軍至夏口，周瑜問：「荊州有人在前面接否？」人報：「劉皇叔使糜竺來見都督。」瑜喚至，問勞軍如何。糜竺曰：「主公皆準備安排下了。」瑜曰：「皇叔何在？」竺曰：「在荊州城門相等，與都督把盞。」瑜曰：「今為汝家之事，出兵遠征；勞軍之禮，休得輕易。」糜竺領了言語先回。
戰船密密排在江上，依次而進。\n```\n_輸出：(可以看到在\"戰船\"前面有換行)_\n\n前軍至夏口，周瑜問：「荊州有人在前面接否？」人報：「劉皇叔使糜竺來見都督。」瑜喚至，問勞軍如何。糜竺曰：「主公皆準備安排下了。」瑜曰：「皇叔何在？」竺曰：「在荊州城門相等，與都督把盞。」瑜曰：「今為汝家之事，出兵遠征；勞軍之禮，休得輕易。」糜竺領了言語先回。
戰船密密排在江上，依次而進。\n\n### 1.2 標題 (Heading)\n\n_範例語法：_\n\n```\n# 主標題 (等同於 HTML ``)\n\n## 次標題 (等同於 ``)\n\n#### 第四階 (等同於 ``)\n\n##### 第五階 (等同於 ``)\n\n###### 第六階 (等同於 ``)\n```\n\n_輸出：_\n\n# 主標題 (等同於 HTML ``)\n\n## 次標題 (等同於 `
`)\n\n#### 第四階 (等同於 ``)\n\n##### 第五階 (等同於 ``)\n\n###### 第六階 (等同於 ``)\n\n### 1.3 無序號列表 (Bullet list)\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### 1.4 序號列表 (Numbered list)\n\n_範例語法：_\n\n```\n1. 第一項\n2. 第二項\n3. 第三項\n```\n\n_輸出：_\n\n1. 第一項\n2. 第二項\n3. 第三項\n\n### 1.5 區塊引言 (blockquoting)\n\n_範例語法：_\n\n```\n> 卻說魯肅回見周瑜，說玄德，孔明歡喜不疑，準備出城勞軍。周瑜大笑曰：「原來今番也中了吾計！」便教魯肅稟報吳侯，並遣程普引兵接應。周瑜此時箭瘡已漸平愈，身軀無事，使甘寧為先鋒，自與徐盛，丁奉為第二；淩統，呂蒙為後隊。水陸大兵五百萬，望荊州而來。\n\n周瑜在船中，時復歡笑，以為孔明中計。\n\n> 前軍至夏口，周瑜問：「荊州有人在前面接否？」人報：「劉皇叔使糜竺來見都督。」瑜喚至，問勞軍如何。\n```\n\n_輸出：_\n\n> 卻說魯肅回見周瑜，說玄德，孔明歡喜不疑，準備出城勞軍。周瑜大笑曰：「原來今番也中了吾計！」便教魯肅稟報吳侯，並遣程普引兵接應。周瑜此時箭瘡已漸平愈，身軀無事，使甘寧為先鋒，自與徐盛，丁奉為第二；淩統，呂蒙為後隊。水陸大兵五百萬，望荊州而來。\n\n周瑜在船中，時復歡笑，以為孔明中計。\n\n> 前軍至夏口，周瑜問：「荊州有人在前面接否？」人報：「劉皇叔使糜竺來見都督。」瑜喚至，問勞軍如何。\n\n### 1.6 程式碼區塊\n\n_範例語法：_\n\n\\`\\`\\`julia\n\nprintln(\"Hello Julia\")\n\n\\`\\`\\`\n\n_輸出：_\n\n```julia\nprintln(\"Hello Julia\")\n```\n\n### 1.7 分隔線\n\n_範例語法：_\n\n```\n卻說魯肅回見周瑜，說玄德，孔明歡喜不疑，準備出城勞軍。周瑜大笑曰：「原來今番也中了吾計！」便教魯肅稟報吳侯，並遣程普引兵接應。周瑜此時箭瘡已漸平愈，身軀無事，使甘寧為先鋒，自與徐盛，丁奉為第二；淩統，呂蒙為後隊。水陸大兵五百萬，望荊州而來。周瑜在船中，時復歡笑，以為孔明中計。\n\n---\n\n前軍至夏口，周瑜問：「荊州有人在前面接否？」人報：「劉皇叔使糜竺來見都督。」瑜喚至，問勞軍如何。糜竺曰：「主公皆準備安排下了。」瑜曰：「皇叔何在？」竺曰：「在荊州城門相等，與都督把盞。」瑜曰：「今為汝家之事，出兵遠征；勞軍之禮，休得輕易。」糜竺領了言語先回。
戰船密密排在江上，依次而進。\n```\n\n_輸出：_\n\n卻說魯肅回見周瑜，說玄德，孔明歡喜不疑，準備出城勞軍。周瑜大笑曰：「原來今番也中了吾計！」便教魯肅稟報吳侯，並遣程普引兵接應。周瑜此時箭瘡已漸平愈，身軀無事，使甘寧為先鋒，自與徐盛，丁奉為第二；淩統，呂蒙為後隊。水陸大兵五百萬，望荊州而來。周瑜在船中，時復歡笑，以為孔明中計。\n\n---\n\n前軍至夏口，周瑜問：「荊州有人在前面接否？」人報：「劉皇叔使糜竺來見都督。」瑜喚至，問勞軍如何。糜竺曰：「主公皆準備安排下了。」瑜曰：「皇叔何在？」竺曰：「在荊州城門相等，與都督把盞。」瑜曰：「今為汝家之事，出兵遠征；勞軍之禮，休得輕易。」糜竺領了言語先回。
戰船密密排在江上，依次而進。\n\n### 1.8 超連結\n\n_範例語法：_\n\n```\n[Cupoy - 為你探索世界的新知](https://www.cupoy.com)\n```\n\n_輸出：_\n\n[Cupoy - 為你探索世界的新知](https://www.cupoy.com)\n\n### 1.9 嵌入圖片\n\n_範例語法：_\n\n```\n\n```\n\n_輸出：_\n\n\n\n### 1.10 表格\n\n_範例語法：_\n\n```\n|姓名|國家|地址|年齡|\n|---|---|---|---|\n|John Doe|中華民國台灣|台北市大安區敦化街1號|25|\n```\n\n_輸出：_\n\n|姓名|國家|地址|年齡|\n|---|---|---|---|\n|John Doe|中華民國台灣|台北市大安區敦化街1號|25|\n\n## 2. 用 LaTeX 寫數學公式\n\n### 2.1 Inline 模式\n\n_範例語法：_\n\n```\n$\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)$\n```\n\n_輸出：_\n\n$\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)$\n\n### 2.2 Block 模式\n\n_範例語法：_\n\n```\n$$\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)$$\n```\n\n_輸出：_\n\n$$\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)$$\n\n_範例語法：_\n\n```\n\\begin{equation}\n\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)\n\\end{equation}\n```\n\n_輸出：_\n\n\\begin{equation}\n\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)\n\\end{equation}\n\n_範例語法：_\n\n```\n\\begin{align}\n\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)\n\\end{align}\n```\n\n_輸出：_\n\n\\begin{align}\n\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)\n\\end{align}\n\n## 3. 結合 Markdown 和 LaTeX 數學公式\n\n_範例語法：_\n\n```\n公式 $\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)$ 是 Deep Learning 課程中常會見到的基本公式\n\n\n\n結合 Markdown 和 LaTeX 數學公式，我們可以撰寫出漂亮的文件筆記，讓學習更有效率。\n```\n\n_輸出：_\n\n公式 $\\LARGE f(\\displaystyle\\sum_i w_i x_i + b)$ 是 Deep Learning 課程中常會見到的基本公式\n\n\n\n結合 Markdown 和 LaTeX 數學公式，我們可以撰寫出漂亮的文件筆記，讓學習更有效率。\n\n\n```julia\n\n```\n", "meta": {"hexsha": "19f6937068432b598155e3b529a82d480dd8e4cc", "size": 8094, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "example/julia_002_example.ipynb", "max_stars_repo_name": "h164654156465/1st-JuliaMarathon", "max_stars_repo_head_hexsha": "f247b3bd50c15b0ca31c134e8c52d824b346ee8b", "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": "example/julia_002_example.ipynb", "max_issues_repo_name": "h164654156465/1st-JuliaMarathon", "max_issues_repo_head_hexsha": "f247b3bd50c15b0ca31c134e8c52d824b346ee8b", "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": "example/julia_002_example.ipynb", "max_forks_repo_name": "h164654156465/1st-JuliaMarathon", "max_forks_repo_head_hexsha": "f247b3bd50c15b0ca31c134e8c52d824b346ee8b", "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": 8094.0, "max_line_length": 8094, "alphanum_fraction": 0.6121818631, "converted": true, "num_tokens": 3369, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3311197396289915, "lm_q2_score": 0.2018132246607271, "lm_q1q2_score": 0.06682434240334713}}
{"text": "# Announcments\n\n* Start the CP if you haven't already\n* We have a course tutor, Brady Moore bradenm3@illinois.edu\n\n\n```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## Binary Nuclear Reactions\n\n### Learning Objectives:\n\n- Connect concepts in particle collisions and decay to binary reactions\n- Categorize nuclear reactions using standard nomenclature\n- Apply conservation of nucleons to binary nuclear reactions\n- Formulate Q value equations for binary nuclear reactions\n- Apply conservation of energy and linear momentum to scattering\n- Apply coulombic threshold\n- Apply kinematic threshold\n- Determine when coulombic and kinematic thresholds apply or do not\n\n## Recall from Weeks 3 & 4\n\nTo acheive these objectives, we need to recall 3 major themes from weeks three and four. \n\n### 1: Compare Exothermic and Endothermic reactions\n\n- In **_exothermic_** or **_exoergic_** reactions, energy is **emitted** ($Q>0$)\n- In **_endothermic_** or **_endoergic_** reactions, energy is **absorbed** ($Q<0$)\n\n\n\n\n
\nTable of Contents
\n\n\n\n```python\n# my first python script\nprint(\"hello world! \\n I am Cheng-Jun Wang.\")\n```\n\n hello world! \n I am Cheng-Jun Wang.\n\n\nUses include: \n- data cleaning and transformation, \n- numerical simulation, \n- statistical modeling, \n- machine learning \n- and much more.\n\n\n\n```python\nprint('hello world')\n```\n\n hello world\n\n\n\n```python\n1 + 1\n```\n\n\n\n\n 2\n\n\n\n$E = MC^2$\n\n\\begin{align}\n\\dot{x} & = \\sigma(y-x) \\\\\n\\dot{y} & = \\rho x - y - xz \\\\\n\\dot{z} & = -\\beta z + xy\n\\end{align}\n\n# 搜狗输入法表情和符号\n\n- ∫ ∑ ※ ➕➖✖️➗ ❎ √ ×\n- 😪😠😡😎☺️😁📚🌲\n- 👌👍👎👂👃👀✋❌💰🌂\n- 0️⃣1️⃣2️⃣3️⃣4️⃣5️⃣6️⃣7️⃣8️⃣9️⃣②🔟 \n- 🐶🐱🐔🐷🐖🐴🐎🐂🐑🐯🐧🐺🐒🐵🐻🐦🐲\n- 💻 🌈🌎☁️❄️🏃♀👩👱✨\n- 🆚🔥🌹✈️🌉🎄\n\n(✿◡‿◡)害羞 ⁄(⁄ ⁄•⁄ω⁄•⁄ ⁄)⁄ d=====(￣▽￣*)b厉害 \n\n我是我，不一样花火。～(￣▽￣～)(～￣▽￣)～ 矜持 \n\n\n```python\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nxi = [1, 2, 3, 4, 5]\ny = [3, 5, 9, 13, 16]\n\nplt.plot(xi, y, 'g-s')\nplt.xlabel('$x_i$', fontsize = 20)\nplt.ylabel('$y$', fontsize = 20)\nplt.title('$Scatter\\,Plot$', fontsize = 20)\nplt.show()\n```\n\n# 一级标题\n## 二级标题\n[复旦大学](http://www.fdu.edu.cn)是一个*非常棒*的大学！\n\n1. point 1\n1. point 2\n1. point 3\n\n# 运行C代码\n\nC functions are typically split into header files (.h) where things are declared but not defined, and implementation files (.c) where they are defined. http://people.duke.edu/~ccc14/sta-663/CrashCourseInC.html#a-tutorial-example-coding-a-fibonacci-function-in-c\n\n\n```python\n%%file hello.c\n#include
\n\n\n\n# END\n\nThis is the end.\n\n\n```python\n\n```\n", "meta": {"hexsha": "975ecc6596347fbc40b364675ae545b34335b776", "size": 32583, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "code/01.jupyter_notebook.ipynb", "max_stars_repo_name": "computational-class/cjc", "max_stars_repo_head_hexsha": "1569ce7a7a85571bd2e399ab20fb950d7f8963b2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 65, "max_stars_repo_stars_event_min_datetime": "2017-04-06T01:00:19.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-16T15:30:30.000Z", "max_issues_repo_path": "code/01.jupyter_notebook.ipynb", "max_issues_repo_name": "AnxietyVendor/cjc", "max_issues_repo_head_hexsha": "4bfd22ea4f360a803093a95bd9b1a2d497b7200a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 90, "max_issues_repo_issues_event_min_datetime": "2017-05-12T10:09:06.000Z", "max_issues_repo_issues_event_max_datetime": "2019-09-17T13:13:22.000Z", "max_forks_repo_path": "code/01.jupyter_notebook.ipynb", "max_forks_repo_name": "AnxietyVendor/cjc", "max_forks_repo_head_hexsha": "4bfd22ea4f360a803093a95bd9b1a2d497b7200a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 48, "max_forks_repo_forks_event_min_datetime": "2017-03-22T02:58:34.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-16T03:08:47.000Z", "avg_line_length": 44.210312076, "max_line_length": 13464, "alphanum_fraction": 0.6948101771, "converted": true, "num_tokens": 2062, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3522017684487511, "lm_q2_score": 0.18713267762907493, "lm_q1q2_score": 0.06590845999551023}}
{"text": "| Software Version Python 3.5.4 64bit [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] IPython 6.2.1 OS Darwin 18.6.0 x86_64 i386 64bit numpy 1.16.3 matplotlib 3.0.1 pandas 0.23.4 scipy 1.1.0 statsmodels 0.9.0 Fri Jun 07 14:29:42 2019 CST Hands-on AI II
\nUnit 7 — Introduction to Reinforcement Learning (Assignment)
\n\nAuthors: B. Schäfl, S. Lehner, J. Brandstetter
\nDate: 11-06-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:
\nThis material, no matter whether in printed or electronic form, may be used for personal and non-commercial educational use only. Any reproduction of this manuscript, no matter whether as a whole or in parts, no matter whether in printed or in electronic form, requires explicit prior acceptance of the authors.\n\nTable of contents
\n\n
\n\n\n
\n How 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 u7_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 u7_utils.py need to be installed.\n\n\n```python\n# Import pre-defined utilities specific to this notebook.\nimport u7_utils as u7\n\n# Import additional utilities needed in this notebook.\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport seaborn as sns\nimport sys\nimport time\n\nfrom IPython import display\nfrom typing import Any, Dict, Tuple\n\n# Setup Jupyter notebook (warning: this may affect all Jupyter notebooks running on the same Jupyter server).\nu7.setup_jupyter()\n```\n\n\n\n\n\n\nModule versions
\nAs mentioned in the introductory slides, specific minimum versions of Python itself as well as of used modules is recommended.\n\n\n```python\nu7.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 Installed rdkit version: 2020.09.1 (✓)\n Installed gym version: 0.18.3 (✓)\n\n\nDissection of an Environment
\n
There are four types of surfaces described in this environment:\n
![](\"https://commons.wikimedia.org/wiki/File:Geiger-Marsden_experiment_expectation_and_result.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Emission_spectrum-H.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Bohr-atom-PAR.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Hydrogen_transitions.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Sommerfeld_ellipses.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Breit-rabi-Zeeman.png\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Table_isotopes_en.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Liquid_drop_model.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Bethe-Weizs%C3%A4cker.png\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:Compton-scattering.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:MaxwellBoltzmann-en.svg\"){kind=link}
![](\"https://commons.wikimedia.org/wiki/File:ThermalFissionYield.svg\"){kind=link}
![Wikipedia](\"https://en.wikipedia.org/wiki/Projectile_motion#/media/File:Inclinedthrow2.gif\"){kind=link}
S $\\rightarrow$ starting point (safe)F $\\rightarrow$ frozen surface (safe)H $\\rightarrow$ hole (fall to your doom)G $\\rightarrow$ goal (frisbee location)gym module is available in the lecture's notebook.\n\nThe first and naïve approach to solve this task is by simply brute forcing it applying random search. The outline of this approach is the following:\n
| Step | \nDescription | \n
|---|---|
| 0 | \nChoose a random action with respect to the current state. | \n
| 1 | \nExecute previously chosen action and transition into a new state. | \n
| 2 | \nRepeat the previous steps as long as the current episode is still ongoing. | \n
n of the action_space and observation_space of the respective environment gives the amount of actions as well as states.\n\n\n```python\nnum_actions = enviroment_lake.action_space.n\nnum_states = enviroment_lake.observation_space.n\nprint(f'The FrozenLake-v0 environment comprises <{num_actions}> actions and <{num_states}> states.')\n```\n\n The FrozenLake-v0 environment comprises <4> actions and <16> states.\n\n\n\n```python\ncurrent_state_id = enviroment_lake.s\nenviroment_lake.P[current_state_id]\n```\n\n\n\n\n {0: [(0.3333333333333333, 0, 0.0, False),\n (0.3333333333333333, 0, 0.0, False),\n (0.3333333333333333, 4, 0.0, False)],\n 1: [(0.3333333333333333, 0, 0.0, False),\n (0.3333333333333333, 4, 0.0, False),\n (0.3333333333333333, 1, 0.0, False)],\n 2: [(0.3333333333333333, 4, 0.0, False),\n (0.3333333333333333, 1, 0.0, False),\n (0.3333333333333333, 0, 0.0, False)],\n 3: [(0.3333333333333333, 1, 0.0, False),\n (0.3333333333333333, 0, 0.0, False),\n (0.3333333333333333, 0, 0.0, False)]}\n\n\n\nEach entry of the reward table contains a dictionary of the form s: {a: [] for a in range(nA)} for s in range(nS).\n
| Element | \nDescription | \n
|---|---|
nS=nrows*ncols | \n The number of possible moves. | \n
nA=4 | \n Number of surfaces. [S,F,H,G] | \n
a | \n Potential state based on the surface of the next move. | \n
Previously, we talked about solving this task in a naïve way by simply applying brute force: using random search. In the meantime we analyzed the action as well as the state space and came to the conclusion, that such an approach is more than feasible. To repeat the outline of such an approach:\n
I $\\rightarrow$ choose a random action with respect to the current state.II $\\rightarrow$ execute previously chosen action and transition into a new state.III $\\rightarrow$ if the episode is finished, but the goal not reached, reset the position of the disc retrieving entity.IV). Adapt the function apply_random_search as discussed during the lecture. Mark the corresponding sections of the code using I, II, III and IV. Note that our random search is not guaranteed to find the solution of a task in finite time, hence an upper border on the runtime is often applied as a safety net (in our case the number of allowed steps).\n\nTo drill down on the drawbacks of plain random search, we are designing the following experimental setup (hint: it is actually the same experimental setup as already discussed during the exercise, so you might orient yourself on the implementation presented during class):\n
In a simplified version of $Q$-learning, the $\\boldsymbol{Q}$-value\n\\begin{equation}\n Q(s,a)\n\\end{equation}
\n\nis the expected future reward of being in state $s$ and taking action $a$. Intuitively, if the the $Q$-values are learned correctly, a good policy would be to take the action which maximizes the expected future reward. This is what $Q$-learning is doing. $Q$-learning lets the agent use the environment's rewards to learn, over time, the best action to take in a given state. $Q$-values are initialized to an arbitrary value, and as the agent exposes itself to the environment and receives different rewards by executing different actions, the $Q$-values are updated using the equation:\n\\begin{equation}\n Q(s_t,a_t) \\leftarrow (1 - \\alpha) \\cdot Q(s_t,a_t) + \\alpha \\cdot \\left( r + \\max_{a_{t+1}} Q(s_{t+1}, a_{t+1})\\right)\n\\end{equation}
\n\nWe are assigning $\\leftarrow$, or updating, the $Q$-value of the agent's current state and action, denoted as $Q(s_t,a_t)$ with $\\alpha$ as the learning rate, i.e the extent to which our $Q$-values are being updated in every iteration.
\n\nThe $\\boldsymbol{Q}$-table is a matrix where we have a row for every state and a column for every action – $500$ and $6$, respectively, when referring to the Taxi-v3 example, as discussed during class. It's first initialized to $0$, and then values are updated after training.
\n\nPreviously, we talked about solving this task in a naïve way by simply applying brute force: using random search. This time we want to apply a more sophisticated algorithm – $Q$-learning:\n
I $\\rightarrow$ Choose action $a_t$.\n II $\\rightarrow$ Go from state $s_t$ to state $s_{t+1}$ by taking action $a_{t}$.\n III $\\rightarrow$ For all possible $Q$-values from the state $s_{t+1}$, select the highest.\n IV $\\rightarrow$ Update $Q$-table values using the equation from above.\n V $\\rightarrow$ Set the next state as the current state.\nVI).\n\nVery likely the $Q$-table of the previous experiment looked a little bit odd. Try to add exploration to your algorithm by adapting your $Q$-learning implementation:\n
I $\\rightarrow$ Throw a random uniform number between $0$ and $1$. \n II $\\rightarrow$ If the number is smaller than $0.1$, sample a random action.\n III $\\rightarrow$ Otherwise, choose your action as usual.\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# Math for devs\n## Author: Antonio DIchev\n\nThis is a list:\n* 1\n* 2\n* 3\n\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\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$$y=ax+b$$\n\n$$ax^2+bx+c=0$$\n\n$$x_{1,2}= \\frac{-b\\pm \\sqrt{b^2-4ac}}{2a}$$\n\n$$f(x)|_{x=a} = f(a)+f'(a)(x-a)+\\frac{f''(a)}{2!}(x-a)^2+...+\\frac{f^(n)(a)}{n!}(x-a)^n+...$$\n\n$$(x+y)^n=\\begin{pmatrix}n\\\\0\\end{pmatrix}x^ny^0+\\begin{pmatrix}n\\\\1\\end{pmatrix}x^1y^{n-1}+...\\begin{pmatrix}n\\\\n\\end{pmatrix}x^0y^{n}=\\sum^n\\limits_{k=0}\\begin{pmatrix}n\\\\k\\end{pmatrix}x^{n-k}y^{k} $$\n\n$$\\int_{-\\infty}^{+\\infty}e^{-x^2}dx=\\sqrt\\pi$$\n\n$$\\begin{pmatrix}\n2 & 1 & 3 \\\\\n2 & 6 & 8 \\\\\n6 & 8 & 18\n\\end{pmatrix} $$\n\n\n$$A = \\begin{bmatrix} \n a_{11} & a_{12} & \\dots & a_{1n} \\\\\n a_{21} & a_{22} & \\dots & a_{2n} \\\\\n \\vdots & \\vdots & \\ddots & \\vdots \\\\\n a_{m1} & a_{m2} & \\dots & a_{mn} \\\\\n \\end{bmatrix}$$\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\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\nimport math\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 return []\n elif D == 0:\n x = (-b+math.sqrt(b**2-4*a*c))/2*a\n return x\n else:\n x1 = (-b-math.sqrt(b**2-4*a*c))/2*a\n x2 = (-b+math.sqrt(b**2-4*a*c))/2*a\n return x1, x2\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\nimport numpy as np\nimport matplotlib.pyplot as plt\nx = np.linspace(-3, 5, 1000)\ny = 2 * x + 3\nplt.plot(x, y)\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\nplt.plot(x, y)\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)\nplt.show()\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$$\\ln y=b*x+\\ln a$$\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 plot_math_function(f, min_x, max_x, num_points):\n \n \n f_vectorized = np.vectorize(f)\n x=np.linspace(min_x,max_x,num_points)\n y = f_vectorized(x)\n \n plt.plot(x, y)\n ax = plt.gca()\n ax.spines[\"bottom\"].set_position(\"zero\")\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n plt.show()\n```\n\n\n```python\n#x = np.linspace(-15,15,100) # 100 linearly spaced numbers\n#y = np.sin(x)/x # computing the values of sin(x)/x\n\n# compose plot\n#plt.plot(x,y) # sin(x)/x\n#plt.plot(x,y,'co') # same function with cyan dots\n#plt.plot(x,2*y,x,3*y) # 2*sin(x)/x and 3*sin(x)/x\n#plt.show() # show the plot\n```\n\n\n```python\n\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 \n vectorized_fs = [np.vectorize(f) for f in functions]\n x=np.linspace(min_x,max_x,num_points) \n \n ys = [vectorized_f(x) for vectorized_f in vectorized_fs]\n \n \n #y = [y for y in ys]\n\n for i in ys: #ys is my range of y values on the chart\n plt.plot(x, i)\n ax = plt.gca()\n ax.spines[\"bottom\"].set_position(\"zero\")\n ax.spines[\"left\"].set_position(\"zero\")\n ax.spines[\"top\"].set_visible(False)\n ax.spines[\"right\"].set_visible(False)\n plt.show()\n \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.\n\n\n```python\nplot_math_functions([lambda x:np.arcsin(x)], -1, 1, 1000)\nplot_math_functions([lambda x:np.arccos(x)], -1, 1, 1000)\nplot_math_functions([lambda x:np.arctan(x)], -1, 1, 1000)\nplot_math_functions([lambda x:np.arctan(1/x)], -1, 1, 1000)\n```\n\n\n```python\ndef plot_circle(x_c, y_c, r):\n \"\"\"\n Plots the circle with center C(x_c; y_c) and radius r.\n This corresponds to plotting the equation x^2 + y^2 = r^2\n \"\"\"\n ##(x−x_c)**2 + (y−y_c)**2 = r**2\n\n x = np.linspace(-r+x_c,r+x_c,1000)\n y = y_c+np.sqrt(-(x-x_c)**2+r**2)\n y2 = y_c-np.sqrt(-(x-x_c)**2+r**2)\n plt.plot(x, y,'b')\n plt.plot(x, y2,'b')\n plt.gca().set_aspect('equal')\n plt.show()\n```\n\n\n```python\nplot_circle(300, 300, 600)\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": "ea75c3c9414d0a4c237814370a64b5fac8d62f38", "size": 260882, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "High_Shool_Maths/High-School-Maths-Exercise.ipynb", "max_stars_repo_name": "ivaylokanov/Math_Concepts_for_Developers", "max_stars_repo_head_hexsha": "646d4d5de48535c22b9a8fcb624973b917661c5e", "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": "High_Shool_Maths/High-School-Maths-Exercise.ipynb", "max_issues_repo_name": "ivaylokanov/Math_Concepts_for_Developers", "max_issues_repo_head_hexsha": "646d4d5de48535c22b9a8fcb624973b917661c5e", "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": "High_Shool_Maths/High-School-Maths-Exercise.ipynb", "max_forks_repo_name": "ivaylokanov/Math_Concepts_for_Developers", "max_forks_repo_head_hexsha": "646d4d5de48535c22b9a8fcb624973b917661c5e", "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.0506072874, "max_line_length": 18312, "alphanum_fraction": 0.8983640113, "converted": true, "num_tokens": 7896, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.15203222625389934, "lm_q2_score": 0.4263215925474903, "lm_q1q2_score": 0.06481462081510274}} {"text": "##### Copyright 2020 The Cirq Developers\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# Ion Device Class\n\n
| \n View on QuantumAI\n | \n\n Run in Google Colab\n | \n\n View source on GitHub\n | \n\n Download notebook\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\n \n
\n\n\n \n
\n\n\n \n
\n\n\n \n
\n\n\n\nLa trayectoria rectilínea de una partícula se definirá por medio de un solo eje de coordenadas $s$. \n\nEl origen $O$ en la trayectoria es un punto fijo, y a partir de él se utiliza la coordenada de posición s para especificar la ubicación de la partícula en cualquier instante dado. La magnitud de $s$ es la distancia de $O$ a la partícula (en unidades de longitud), y su signo algebraico define el sentido de su dirección.\n\nLa posición es una cantidad vectorial puesto que tiene tanto magnitud como dirección, aunque en este caso se representa por el escalar algebraico $s$ puesto que la dirección se mantiene a lo largo del eje de coordenadas.\n\n\n### Desplazamiento\n\n\n \n
\n\n\n\nEl desplazamiento de la partícula se define como el cambio de su posición, y es dado por:\n\n\n\\begin{equation*}\n\\Delta s= s'-s\n\\label{eq:Ec1_1} \\tag{1.1}\n\\end{equation*}\n\nEn este caso $\\Delta s$ es positivo puesto que la posición final de la partícula queda a la derecha de su posición inicial, es decir, $s'>s$. Asimismo, si la posición final quedara a la izquierda de su posición inicial, $\\Delta s$ sería negativo.\n\nEl desplazamiento de una partícula también es una cantidad vectorial, y deberá distinguirse de la distancia que recorre la partícula. Específicamente, la distancia recorrida es un escalar positivo que representa la longitud total de la trayectoria a lo largo de la cual viaja la partícula.\n\n### Velocidad\n\n\n \n
\n\n\n\nSi la partícula recorre una distancia $\\Delta s$ durante el intervalo $\\Delta t$, su velocidad promedio durante este intervalo es\n\n\n\\begin{equation*}\n\\textbf{v}_{prom}=\\frac{\\Delta s}{\\Delta t}\n\\label{eq:Ec1_2} \\tag{1.2}\n\\end{equation*}\n\nLa velocidad instantánea es una cantidad vectorial definida como \n\n\n\\begin{equation*}\n\\textbf{v}=\\lim_{\\Delta t \\rightarrow 0}\\frac{\\Delta s}{\\Delta t}=\\frac{ds}{dt}\n\\label{eq:Ec1_3} \\tag{1.3}\n\\end{equation*}\n\nComo la dirección temporal siempre será positiva, entonces el signo para determinar el sentido de la velocidad le corresponderá a $ds$. La magnitud de la velocidad es lo que se conoce como *rapidez*.\n\n### Aceleración\n\n\n \n
\n\n\n\nConocida la velocidad de la partícula en dos puntos, la aceleración promedio en un intervalo de tiempo $\\Delta t$ está dada por\n\n\n\\begin{equation*}\n\\textbf{a}_{prom}=\\frac{\\Delta \\textbf{v}}{\\Delta t}\n\\label{eq:Ec1_4} \\tag{1.4}\n\\end{equation*}\n\nLa aceleración instantánea es una cantidad vectorial definida como \n\n\n\\begin{equation*}\n\\textbf{a}=\\lim_{\\Delta t \\rightarrow 0}\\frac{\\Delta \\textbf{v}}{\\Delta t}=\\frac{d\\textbf{v}}{dt}\n\\label{eq:Ec1_5} \\tag{1.5}\n\\end{equation*}\n\nLa aceleración también se puede interpretar como la segunda derivada del desplazamiento respecto al tiempo.\nUna relación diferencial que incluye el desplazamiento, la velocidad y la aceleración a lo largo de una trayectoria, eliminando la dependencia del tiempo es:\n\n\n\\begin{equation*}\n\\textbf{a}ds=\\textbf{v}d\\textbf{v}\n\\label{eq:Ec1_6} \\tag{1.6}\n\\end{equation*}\n\n\n### Aceleración constante\n\nSi la aceleración es constante, se pueden integrar las tres ecuaciones cinemáticas vistas:\n\n$$\\textbf{a}_c=\\frac{d\\textbf{v}}{dt}; \\quad \\textbf{v}=\\frac{ds}{dt}; \\quad \\textbf{a}ds=\\textbf{v}d\\textbf{v}$$\n\n\n#### Velocidad como función del tiempo\n\nIntegrando $a_c=\\frac{d\\textbf{v}}{dt}$, con condiciones iniciales $\\textbf{v}=v_0$ cuando $𝑡=0$\n\n$$\\int_{v_0}^v d\\textbf{v} = \\int_0^t a_c dt$$\n\nSe llega a\n\n\n\\begin{equation*}\n\\textbf{v} = v_0 + a_c t\n\\label{eq:Ec1_7} \\tag{1.7}\n\\end{equation*}\n\n\n#### Posición como función del tiempo\n\nIntegrando $\\textbf{v}=ds/dt=v_0 + a_c t$, con condiciones iniciales $s=s_0$ cuando $𝑡=0$\n\n$$\\int_{s_0}^s ds = \\int_0^t (v_0 +a_c t) dt$$\n\nSe llega a\n\n\n\\begin{equation*}\ns = s_0 + v_0 t +\\frac{1}{2} a_c t^2\n\\label{eq:Ec1_8} \\tag{1.8}\n\\end{equation*}\n\n\n#### Velocidad como función de la posición\n\nIntegrando $\\textbf{v}d\\textbf{v}=a_c ds$, con condiciones iniciales $v=v_0$ cuando $s=s_0$\n\n$$\\int_{v_0}^v \\textbf{v}d\\textbf{v} = \\int_{s_0}^s a_c ds$$\n\nSe llega a\n\n\n\\begin{equation*}\nv^2 = v_0^2 + 2a_c (s-s_0)\n\\label{eq:Ec1_9} \\tag{1.9}\n\\end{equation*}\n\n#### Observaciones\n\n- Las ecuaciones anteriores son útiles cuando la aceleración es constante y cuando $t=0$, $s=s_0$ y $v=v_0$.\n\n\n- Si se conoce una relación entre dos de las cuatro variables, $\\textbf{a}$, $\\textbf{v}$, $s$ y $t$, entonces se puede obtener una tercera variable con una de las ecuaciones cinemáticas, $\\textbf{a}=d\\textbf{v}/dt$, $\\textbf{v}=ds/dt$ o $\\textbf{a}ds=\\textbf{v}d\\textbf{v}$, puesto que cada ecuación relaciona las tres variables.\n\n\n- Siempre que se realice una integración, es importante que se conozcan la posición y la velocidad en un instante dado para evaluar o la constante de integración si se utiliza una integral indefinida, o los límites de integración si se utiliza una integral definida.\n\n### Recapitulando\n\n- La dinámica se ocupa de cuerpos que tienen movimiento acelerado.\n\n\n- La cinemática es un estudio de la geometría del movimiento.\n\n\n- La cinética es un estudio de las fuerzas que causan el movimiento.\n\n\n- La cinemática rectilínea se refiere al movimiento en línea recta.\n\n\n- La rapidez se refiere a la magnitud de la velocidad.\n\n\n- La rapidez promedio es la distancia total recorrida, dividida entre el tiempo total. Ésta es diferente de la velocidad promedio, la cual es el desplazamiento dividido entre el tiempo.\n\n\n- Una partícula que reduce el paso está desacelerando.\n\n\n- Una partícula puede tener una aceleración y al mismo tiempo una velocidad cero.\n\n\n- La relación $\\textbf{a}ds=\\textbf{v} d\\textbf{v}$ se deriva de $\\textbf{a}=d\\textbf{v}/dt$ y $\\textbf{v}=ds/dt$, al eliminar $dt$.\n\n\n### Ejemplos\n\n#### Desplazamiento rectilíneo de un Automovil\n\n| \n | \n\n Ejemplo 12.1: Hibbeler R. Engineering Mechanics: Dynamics \n\nEl automóvil de la figura se desplaza en línea recta de modo que durante un corto tiempo su velocidad está definida por $\\textbf{v}=3t^2 + 2t$ pies/s, donde $t$ está en segundos. Determine su posición y aceleración cuando $t = 3 s$. Cuando $t = 0, s = 0$. \n | \n
| \n | \n Ejemplo 12.3: Hibbeler R. Engineering Mechanics: Dynamics \nDurante una prueba un cohete asciende a $75 m/s$ y cuando está a $40 m$ del suelo su motor falla. Determine la altura máxima $s_B$ alcanzada por el cohete y su velocidad justo antes de chocar con el suelo. Mientras está en movimiento, el cohete se ve sometido a una aceleración constante dirigida hacia abajo de $9.81 m/s^2$ debido a la gravedad. Ignore la resistencia del aire. \n | \n
| \n | \n Ejemplo 12.3: Hibbeler R. Engineering Mechanics: Dynamics \nUna partícula metálica se somete a la influencia de un campo magnético a medida que desciende a través de un fluido que se extiende de la placa $A$ a la placa $B$. Si la partícula se libera del reposo en el punto medio $C$, $s=100 mm$ y la aceleración es $a=(4s) m/s^2$, donde $s$ está en metros, determine la velocidad de la partícula cuando llega a la placa $B$, $s=200 mm$ y el tiempo que le lleva para ir de $C$ a $B$. \n | \n
| Hibbeler R. Engineering Mechanics: Dynamics | \n\n \n La gráfica de $v-t$ se construye a partir de la gráfica de $s-t$, fig. (a), se utilizará la ecuación $v=ds/dt$, ya que relaciona las variables $s$ y $t$ con $v$. Esta ecuación establece que\n \n\n $$\\underbrace{\\frac{ds}{dt}}_{\\text{pendiente gráfica s-t}}=\\underbrace{v}_{velocidad}$$\n \n\n Por ejemplo, si se mide la pendiente en la gráfica de $s-t$ cuando $t=t_1$, la velocidad es $v_1$, la cual se traza en la fig. (b). La gráfica de $v-t$ se construye trazando ésta y otros valores en cada instante. \n \n | \n
| Hibbeler R. Engineering Mechanics: Dynamics | \n\n \n La gráfica de $a-t$ se construye a partir de la gráfica de $v-t$ del mismo modo, figs. (a) y (b) puesto que\n \n\n $$\\underbrace{\\frac{dv}{dt}}_{\\text{pendiente gráfica v-t}}=\\underbrace{a}_{acelereción}$$\n \n\nSi la curva $s-t$ correspondiente a cada intervalo de movimiento puede\nexpresarse mediante una función matemática $s=s(t)$, entonces la ecuación\nde la gráfica de $v-t$ correspondiente al mismo intervalo se obtiene\ndiferenciando esta función con respecto al tiempo puesto que $v=ds/dt$.\n \n\nAsimismo, la ecuación de la gráfica de $a-t$ en el mismo intervalo se determina\nal diferenciar $v=v(t)$ puesto que $a=dv/dt$. Como la diferenciación\nreduce un polinomio de grado $n$ a uno de grado $n-1$, en tal caso si la\ngráfica de $s-t$ es parabólica (una curva de segundo grado), la gráfica de\n$v-t$ será una línea inclinada (una curva de primer grado) y la gráfica de $a-t$\nserá una constante o una línea horizontal (una curva de grado cero). \n \n | \n
| Hibbeler R. Engineering Mechanics: Dynamics | \n\n \n Si se tiene la gráfica de $a-t$, como se muestra en la figura al lado, la gráfica de $v-t$ se construye mediante $a=dv/dt$, escrita como\n \n\n$$\\underbrace{\\Delta v}_{\\text{Cambio de la velocidad}}=\\underbrace{\\int adt}_{\\text{área bajo la curva de a-t}}$$\n \n\nPara construir la gráfica $v-t$, se parte de la velocidad inicial de la partícula, $v_0$ y luego se va adicionando pequeños incrementos de área ($\\Delta v$) determinados a partir de la gráfica $a-t$. Con esto, se tienen una serie de puntos sucesivos, $v_i=v_{i-1}+\\Delta v$ que irán conformando la gráfica $v-t$\n \n\nLa adición algebráica de los incrementos de área de la gráfica $a-t$ es necesaria, ya que las áreas situadas por encima del eje $t$ corresponden a un incremento de $v$ (área \"positiva\"), mientras que las que quedan debajo del eje indican una reducción de $v$ (área \"negativa\"). \n \n | \n
| Hibbeler R. Engineering Mechanics: Dynamics | \n\n \n De igual forma, si se tiene la gráfica de $v-t$, como se muestra en la figura al lado, la gráfica de $s-t$ se construye mediante $v=ds/dt$, escrita como\n \n\n$$\\underbrace{\\Delta s}_{\\text{desplazamiento}}=\\underbrace{\\int vdt}_{\\text{área bajo la curva de v-t}}$$\n \n\nigual que en la anterior gráfica, se parte de la posición inicial de la partícula, $s_0$ y luego se va adicionando pequeños incrementos de área ($\\Delta s$) determinados a partir de la gráfica $v-t$.\n \n\nLos segmentos de la gráfica $a-t$ pueden describirse mediante una serie de ecuaciones, que a su vez pueden integrarse para obtener los segmentos correspondientes a l gráfica $v-t$. Por lo tanto, si la gráfica $a-t$ es lineal, la integración dará una gráfica para $v-t$ cuadrática, y para $s-t$, una cúbica.\n \n | \n
| Hibbeler R. Engineering Mechanics: Dynamics | \n\n \n Los puntos de la gráfica $v-s$ se determinana por medio de la ecuación $vdv=ads$. Integrando esta ecuación en los límites $v=v_0$ con $s=s_0$ y $v=v_1$ con $s=s_1$, se tiene\n \n\n$$\\frac{1}{2}\\left( v_1^2 - v_0^2\\right)=\\underbrace{\\int_{s_0}^{s_1} ads}_{\\text{área bajo la curva de a-s}}$$\n \n\nSi se determina el área de color gris y se conoce la velocidad $v_0$ en $s_0=0$, entonces $v_1=\\left( 2 \\int_{s_0}^{s_1}ads+v_0^2\\right)^{1/2}$. De esta forma se pueden marcar puntos sucesivos en la gráfica $v-s$.\n \n | \n
| Hibbeler R. Engineering Mechanics: Dynamics | \n\n \nSi se conoce la gráfica $v-s$, la aceleración $a$ en cualquier posición $s$ se determinar por $ads=vdv$, que se escribe como\n \n\n$$\\underbrace{a}_\\text{aceleración}=\\underbrace{v \\left( \\frac{dv}{ds} \\right)}_{\\text{velocidad por la pendiente de la gráfica de v-s}}$$\n \n\nEntonces, en cualquier punto $(s,v)$ se mide la pendiente $ds/dv$ de la gráfica de $v-s$. Entonces, con $v$ y $dv/ds$ conocidas, se calcula el valor de $a$.\n \n\nLa gráfica de $v-s$ también se construye a partir de la gráfica de $a-s$ o viceversa, por aproximación de la gráfica conocida en varios intervalos con funciones matemáticas, $v=f(s)$ o $a=g(s)$ y luego por $ads=vdv$ para obtener la otra gráfica.\n \n | \n
| \n | \n Ejemplo 12.6: Hibbeler R. Engineering Mechanics: Dynamics \nUna bicicleta rueda a lo largo de una carretera recta de modo que la gráfica de la figura describe su posición. Construya las gráficas de $v-t$ y $a-t$ en el intervalo $0 \\leq t \\leq 30 s$ \n | \n
| \n | \n \n- Gráfica $v-t$: teniendo que $v=ds/dt$, la gráfica de $v-t$ se determina diferenciando las ecuaciones que definen la gráfica $s-t$. En la gráfica se observan dos segmentos:\n\n - ***Segmento 1:*** en el intervalo $0\\leq t<10s$ la función de desplazamiento está dada por la ecuación $s=t^2 pies$, diferenciando esta ecuación respecto al tiempo para determinar la velocidad en ese trayecto, quedaría $v=\\frac{ds}{dt}=(2t) pies/s$.\n\n - ***Segmento 2:*** en el intervalo $10s\\leq t<30s$ la función de desplazamiento está dada por la ecuación $s=(20t-100)pies$, diferenciando esta ecuación respecto al tiempo para determinar la velocidad en ese trayecto, quedaría $v=\\frac{ds}{dt}=(20)pies/s$.\n\n\n|$0\\leq t | \n
| \n | \n \n- Gráfica $a-t$: Similarmente, como $a=dv/dt$, la gráfica de $a-t$ se determina diferenciando las ecuaciones que definen la gráfica $v-t$:\n\n - ***Segmento 1:*** en el intervalo $0\\leq t<10s$ la función de velocidad está dada por la ecuación $s=2t pies/s$, diferenciando esta ecuación respecto al tiempo para determinar la aceleración en ese trayecto, quedaría $a=\\frac{dv}{dt}=(2) pies/s^2$.\n\n - ***Segmento 2:*** en el intervalo $10s\\leq t<30s$ la función de velocidad está dada por la ecuación $v=(20)pies/s$, diferenciando esta ecuación respecto al tiempo para determinar la aceleración en ese trayecto, quedaría $a=\\frac{dv}{dt}=(0)pies/s^2$.\n\nSe observa que el primer tramo de la gráfica $a-t$ es una constante de valor $2$, y en el segundo tramo también se tiene una constante, pero de valor cero, $0$.\n \n | \n
| \n View on QuantumAI\n | \n\n Run in Google Colab\n | \n\n View source on GitHub\n | \n\n Download notebook\n | \n
Given the point $\\mathbf{y}$ (black square) we want to find the $\\mathbf{x}$ along the line that is closest to it. The gray circle is the locus of points within a fixed distance from $\\mathbf{y}$.
\n\n\n\n\n\n**Programming Tip.**\n\n[Figure](#fig:probability_001) uses the `matplotlib.patches` module. This\nmodule contains primitive shapes like circles, ellipses, and rectangles that\ncan be assembled into complex graphics. As shown in the code in the IPython\nNotebook corresponding to this chapter, after importing a particular shape, you\ncan apply that shape to an existing axis using the `add_patch` method. The\npatches themselves can by styled using the usual formatting keywords like\n`color` and `alpha`.\n\n\n\n\n\n\n\nThe closest point on the line occurs when the line is tangent to the circle. When this happens, the black line and the line (minimum distance) are perpedicular.
\n\n\n\n\n\n Now that we can see what's going on, we can construct the the solution\nanalytically. We can represent an arbitrary point along the black line as:\n\n$$\n\\mathbf{x}=\\alpha\\mathbf{v}\n$$\n\n where $\\alpha\\in\\mathbb{R}$ slides the point up and down the line with\n\n$$\n\\mathbf{v} = \\left[ 1,1 \\right]^T\n$$\n\n Formally, $\\mathbf{v}$ is the *subspace* onto which we want to\n*project* $\\mathbf{y}$. At the closest point, the vector between\n$\\mathbf{y}$ and $\\mathbf{x}$ (the *error* vector above) is\nperpedicular to the line. This means that\n\n$$\n(\\mathbf{y}-\\mathbf{x} )^T \\mathbf{v} = 0\n$$\n\n and by substituting and working out the terms, we obtain\n\n$$\n\\alpha = \\frac{\\mathbf{y}^T\\mathbf{v}}{ \\|\\mathbf{v} \\|^2}\n$$\n\n The *error* is the distance between $\\alpha\\mathbf{v}$ and $\n\\mathbf{y}$. This is a right triangle, and we can use the Pythagorean\ntheorem to compute the squared length of this error as\n\n$$\n\\epsilon^2 = \\|( \\mathbf{y}-\\mathbf{x} )\\|^2 = \\|\\mathbf{y}\\|^2 - \\alpha^2 \\|\\mathbf{v}\\|^2 = \\|\\mathbf{y}\\|^2 - \\frac{\\|\\mathbf{y}^T\\mathbf{v}\\|^2}{\\|\\mathbf{v}\\|^2}\n$$\n\n where $ \\|\\mathbf{v}\\|^2 = \\mathbf{v}^T \\mathbf{v} $. Note that since $\\epsilon^2 \\ge 0 $, this also shows that\n\n$$\n\\| \\mathbf{y}^T\\mathbf{v}\\| \\le \\|\\mathbf{y}\\| \\|\\mathbf{v}\\|\n$$\n\n which is the famous and useful Cauchy-Schwarz inequality which we\nwill exploit later. Finally, we can assemble all of this into the *projection*\noperator\n\n$$\n\\mathbf{P}_v = \\frac{1}{\\|\\mathbf{v}\\|^2 } \\mathbf{v v}^T\n$$\n\n With this operator, we can take any $\\mathbf{y}$ and find the closest\npoint on $\\mathbf{v}$ by doing\n\n$$\n\\mathbf{P}_v \\mathbf{y} = \\mathbf{v} \\left( \\frac{ \\mathbf{v}^T \\mathbf{y} }{\\|\\mathbf{v}\\|^2} \\right)\n$$\n\n where we recognize the term in parenthesis as the $\\alpha$ we\ncomputed earlier. It's called an *operator* because it takes a vector\n($\\mathbf{y}$) and produces another vector ($\\alpha\\mathbf{v}$). Thus,\nprojection unifies geometry and optimization.\n\n## Weighted distance\n\nWe can easily extend this projection operator to cases where the measure of\ndistance between $\\mathbf{y}$ and the subspace $\\mathbf{v}$ is weighted. We can\naccommodate these weighted distances by re-writing the projection operator as\n\n\n\n\n$$\n\\begin{equation}\n\\mathbf{P}_v=\\mathbf{v}\\frac{\\mathbf{v}^T\\mathbf{Q}^T}{\\mathbf{v}^T\\mathbf{Q v}}\n\\end{equation}\n\\label{eq:weightedProj} \\tag{1}\n$$\n\n where $\\mathbf{Q}$ is positive definite matrix. In the previous\ncase, we started with a point $\\mathbf{y}$ and inflated a circle centered at\n$\\mathbf{y}$ until it just touched the line defined by $\\mathbf{v}$ and this\npoint was closest point on the line to $\\mathbf{y}$. The same thing happens\nin the general case with a weighted distance except now we inflate an\nellipse, not a circle, until the ellipse touches the line.\n\n\n\n\n\n\n\nIn the weighted case, the closest point on the line is tangent to the ellipse and is still perpedicular in the sense of the weighted distance.
\n\n\n\n\n\nNote that the error vector ($\\mathbf{y}-\\alpha\\mathbf{v}$) in [Figure](#fig:probability_003) is still perpendicular to the line (subspace\n$\\mathbf{v}$), but in the space of the weighted distance. The difference\nbetween the first projection (with the uniform circular distance) and the\ngeneral case (with the elliptical weighted distance) is the inner product\nbetween the two cases. For example, in the first case we have $\\mathbf{y}^T\n\\mathbf{v}$ and in the weighted case we have $\\mathbf{y}^T \\mathbf{Q}^T\n\\mathbf{v}$. To move from the uniform circular case to the weighted ellipsoidal\ncase, all we had to do was change all of the vector inner products. Before we\nfinish, we need a formal property of projections:\n\n$$\n\\mathbf{P}_v \\mathbf{P}_v = \\mathbf{P}_v\n$$\n\n known as the *idempotent* property which basically says that once we\nhave projected onto a subspace, subsequent projections leave us in the\nsame subspace. You can verify this by computing Equation ref{eq:weightedProj}.\n\nThus, projection ties a minimization problem (closest point to a line) to an\nalgebraic concept (inner product). It turns out that these same geometric ideas\nfrom linear algebra [[strang2006linear]](#strang2006linear) can be translated to the conditional\nexpectation. How this works is the subject of our next section.\n", "meta": {"hexsha": "79b3606f6ede7166657e3d2a91106e6b55d316de", "size": 126799, "ext": "ipynb", "lang": "Jupyter Notebook", "max_stars_repo_path": "chapters/probability/notebooks/projection.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/projection.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/projection.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": 364.3649425287, "max_line_length": 114721, "alphanum_fraction": 0.9255199173, "converted": true, "num_tokens": 2225, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. NO\n2. NO", "lm_q1_score": 0.3998116550426623, "lm_q2_score": 0.1581743587009343, "lm_q1q2_score": 0.06323995213753228}} {"text": "# Longitudinal Data Analysis\n\n\n```stata\n\n```\n\n# Panel Data Analysis III\n\n| '\n html_str += g._repr_svg_()\n html_str += ' | '\n html_str += '
\nq_0: |0>\n\nq_1: |0>\n\n\n\n\n## Qiskit quantum operations summary: \n### https://qiskit.org/documentation/tutorials/circuits/3_summary_of_quantum_operations.html\n\n\n```python\n# Add a Hadamard gate on qubit 0, putting this in superposition.\nqc.h(0)\n# Add a CX (CNOT) gate on control qubit 0 \n# and target qubit 1 to create an entangled state.\nqc.cx(0, 1)\nqc.draw()\n```\n\n\n\n\n
┌───┐ \nq_0: |0>┤ H ├──■──\n └───┘┌─┴─┐\nq_1: |0>─────┤ X ├\n └───┘\n\n\n\n\n```python\n# Create a classical register with 2 bits\nc = ClassicalRegister(2,'c')\n\nmeas = QuantumCircuit(q,c,name=\"first_m\")\nmeas.barrier(q)\nmeas.measure(q, c)\n\nmeas.draw()\n```\n\n\n\n\n
░ ┌─┐ \nq_0: |0>─░─┤M├───\n ░ └╥┘┌─┐\nq_1: |0>─░──╫─┤M├\n ░ ║ └╥┘\n c_0: 0 ════╩══╬═\n ║ \n c_1: 0 ═══════╩═\n\n\n\n\n\n```python\n# Quantum circuits can be added with + operations\n# Add two pre-defined circuits\nqc_all=qc+meas\nqc_all.draw()\n```\n\n\n\n\n
┌───┐ ░ ┌─┐ \nq_0: |0>┤ H ├──■───░─┤M├───\n └───┘┌─┴─┐ ░ └╥┘┌─┐\nq_1: |0>─────┤ X ├─░──╫─┤M├\n └───┘ ░ ║ └╥┘\n c_0: 0 ══════════════╩══╬═\n ║ \n c_1: 0 ═════════════════╩═\n\n\n\n\n\n```python\n# Draw the quantum circuit in a different (slightly better) format\nqc_all.draw(output='mpl')\n```\n\n\n```python\n# Create the quantum circuit with the measurement in one go.\nqc_all = QuantumCircuit(q,c,name=\"2q_all\")\nqc_all.h(0)\nqc_all.cx(0,1)\nqc_all.barrier()\nqc_all.measure(0,0)\nqc_all.measure(1,1)\nqc_all.draw(output='mpl')\n```\n\n\n```python\n# Use Aer's qasm_simulator\nbackend_q = Aer.get_backend('qasm_simulator')\n\n# Execute the circuit on the qasm simulator.\njob_sim1 = execute(qc_all, backend_q, shots=4096)\n```\n\n\n```python\njob_sim1.status()\n```\n\n\n\n\n
| \n | no | \nyes | \nPr(Ai) | \n
|---|---|---|---|
| sex | \n\n | \n | \n |
| female | \n406 | \n91 | \n0.495513 | \n
| male | \n391 | \n115 | \n0.504487 | \n
| \n | smoker | \nsex | \ncount | \nExpected value | \n(O_ij - E_ij)^2/E_ij | \n
|---|---|---|---|---|---|
| 0 | \nno | \nmale | \n391 | \n402.075773 | \n0.305099 | \n
| 1 | \nyes | \nmale | \n115 | \n103.924227 | \n1.180406 | \n
| 2 | \nno | \nfemale | \n406 | \n394.924227 | \n0.310623 | \n
| 3 | \nyes | \nfemale | \n91 | \n102.075773 | \n1.201781 | \n
\n \n
\n\n\n```python\n# Example : Dot Product\n\nA = [1.0, 3.0, -5.0]\nB = [4.0, -2.0, -1.0]\n\n# Create a variable called dot_product with value, 0.0\ndot_product = 0.0\n\n# Update the value each time the code loops\nfor a , b in zip(A, B):\n dot_product += a * b\n\n# Print the solution\nprint(dot_product)\n```\n\n 3.0\n\n\n(Solution in 02_DataStructures_LibraryFunctions_SOLS.ipynb)\n\n__Check Your Solution:__ \n\nThe dot product $\\mathbf{A} \\cdot \\mathbf{B}$:\n| \n View on QuantumAI\n | \n\n Run in Google Colab\n | \n\n View source on GitHub\n | \n\n Download notebook\n | \n
| \n | train_precision@1 | \ntrain_recall@1 | \ntrain_f1@1 | \ntest_precision@1 | \ntest_recall@1 | \ntest_f1@1 | \ndsub | \nfile_size | \n
|---|---|---|---|---|---|---|---|---|
| 0 | \n0.638 | \n0.277 | \n0.386 | \n0.489 | \n0.211 | \n0.295 | \n-1 | \n5143093 | \n
| 1 | \n0.638 | \n0.277 | \n0.386 | \n0.487 | \n0.210 | \n0.294 | \n2 | \n1181690 | \n
| 2 | \n0.630 | \n0.274 | \n0.381 | \n0.483 | \n0.209 | \n0.291 | \n4 | \n891770 | \n
| 3 | \n0.587 | \n0.255 | \n0.355 | \n0.470 | \n0.203 | \n0.283 | \n8 | \n746810 | \n
| Planet | Mass in kg | Distance to sun in AU |
|---|---|---|
| Earth | $M_{\\mathrm{Earth}}=6\\times 10^{24}$ kg | 1AU |
| Jupiter | $M_{\\mathrm{Jupiter}}=1.9\\times 10^{27}$ kg | 5.20 AU |
| Mars | $M_{\\mathrm{Mars}}=6.6\\times 10^{23}$ kg | 1.52 AU |
| Venus | $M_{\\mathrm{Venus}}=4.9\\times 10^{24}$ kg | 0.72 AU |
| Saturn | $M_{\\mathrm{Saturn}}=5.5\\times 10^{26}$ kg | 9.54 AU |
| Mercury | $M_{\\mathrm{Mercury}}=3.3\\times 10^{23}$ kg | 0.39 AU |
| Uranus | $M_{\\mathrm{Uranus}}=8.8\\times 10^{25}$ kg | 19.19 AU |
| Neptun | $M_{\\mathrm{Neptun}}=1.03\\times 10^{26}$ kg | 30.06 AU |
| Pluto | $M_{\\mathrm{Pluto}}=1.31\\times 10^{22}$ kg | 39.53 AU |
| Relations | Name | matrix elements |
|---|---|---|
| $A = A^{T}$ | symmetric | $a_{ij} = a_{ji}$ |
| $A = \\left (A^{T} \\right )^{-1}$ | real orthogonal | $\\sum_k a_{ik} a_{jk} = \\sum_k a_{ki} a_{kj} = \\delta_{ij}$ |
| $A = A^{ * }$ | real matrix | $a_{ij} = a_{ij}^{ * }$ |
| $A = A^{\\dagger}$ | hermitian | $a_{ij} = a_{ji}^{ * }$ |
| $A = \\left (A^{\\dagger} \\right )^{-1}$ | unitary | $\\sum_k a_{ik} a_{jk}^{ * } = \\sum_k a_{ki}^{ * } a_{kj} = \\delta_{ij}$ |
| $M$ | $M_s$ | $\\alpha$ | State |
|---|---|---|---|
| -2 | 0 | 1 | $\\vert 3,2\\rangle$ |
| -1 | -1 | 3 | $\\vert 2,0\\rangle$ |
| -1 | 0 | 4 | $\\vert 3,0\\rangle$ |
| -1 | 0 | 4 | $\\vert 2,1\\rangle$ |
| -1 | 1 | 5 | $\\vert 3,1\\rangle$ |
| 0 | -1 | 6 | $\\vert 4,2\\rangle$ |
| 0 | 0 | 7 | $\\vert 1,0\\rangle$ |
| 0 | 0 | 7 | $\\vert 5,2\\rangle$ |
| 0 | 0 | 7 | $\\vert 4,3\\rangle$ |
| 0 | 1 | 8 | $\\vert 5,3\\rangle$ |
| 1 | -1 | 9 | $\\vert 4,0\\rangle$ |
| 1 | 0 | 10 | $\\vert 5,0\\rangle$ |
| 1 | 0 | 10 | $\\vert 4,1\\rangle$ |
| 1 | 1 | 11 | $\\vert 5,1\\rangle$ |
| 2 | 0 | 13 | $\\vert 5,4\\rangle$ |
| $R$ | $E_0^{HF}$ |
|---|---|
| 3 | 21.59320 |
| 4 | 20.76692 |
| 5 | 20.7484 |
| 6 | 20.72026 |
| 7 | 20.72013 |
| 8 | 20.71925 |
| 9 | 20.71925 |
| 10 | 20.71922 |
| 11 | 20.71922 |
| 12 | 20.71922 |
| 13 | 20.71922 |
| $R$ | $E_0^{HF}$ |
|---|---|
| 4 | 4.01979 |
| 5 | 3.96315 |
| 6 | 3.87062 |
| 7 | 3.86314 |
| 8 | 3.85288 |
| 9 | 3.85259 |
| 10 | 3.85239 |
| 11 | 3.85239 |
| 12 | 3.85238 |
| 13 | 3.85238 |
| type | test data | B_W | bilge keel | publish geom | publish test | |
|---|---|---|---|---|---|---|
| KVLCC2 | \ntanker | \nTrue | \nsmall | \nFalse | \nTrue | \nTrue | \n
| DTC | \ncontainer | \nTrue | \n? | \n? | \nTrue | \nTrue | \n
| Wallenius | \nPCTC | \nTrue | \nmedium | \nTrue | \nFalse | \nTrue | \n